diff --git a/Gulpfile.ts b/Gulpfile.ts index 4f205bfb0ff01..cc86394d46048 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -138,6 +138,14 @@ const es2017LibrarySourceMap = es2017LibrarySource.map(function(source) { return { target: "lib." + source, sources: ["header.d.ts", source] }; }); +const esnextLibrarySource = [ + "esnext.asynciterable.d.ts" +]; + +const esnextLibrarySourceMap = esnextLibrarySource.map(function (source) { + return { target: "lib." + source, sources: ["header.d.ts", source] }; +}); + const hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"]; const librarySourceMap = [ @@ -152,11 +160,12 @@ const librarySourceMap = [ { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] }, { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] }, { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] }, + { target: "lib.esnext.d.ts", sources: ["header.d.ts", "esnext.d.ts"] }, // JavaScript + all host library { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) }, { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") } -].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap); +].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap); const libraryTargets = librarySourceMap.map(function(f) { return path.join(builtLocalDirectory, f.target); diff --git a/Jakefile.js b/Jakefile.js index 4ef576f6675e6..070f4322d4e03 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -172,13 +172,21 @@ var es2016LibrarySourceMap = es2016LibrarySource.map(function (source) { var es2017LibrarySource = [ "es2017.object.d.ts", "es2017.sharedmemory.d.ts", - "es2017.string.d.ts", + "es2017.string.d.ts" ]; var es2017LibrarySourceMap = es2017LibrarySource.map(function (source) { return { target: "lib." + source, sources: ["header.d.ts", source] }; }); +var esnextLibrarySource = [ + "esnext.asynciterable.d.ts" +]; + +var esnextLibrarySourceMap = esnextLibrarySource.map(function (source) { + return { target: "lib." + source, sources: ["header.d.ts", source] }; +}); + var hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"]; var librarySourceMap = [ @@ -193,11 +201,12 @@ var librarySourceMap = [ { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] }, { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] }, { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] }, + { target: "lib.esnext.d.ts", sources: ["header.d.ts", "esnext.d.ts"] }, // JavaScript + all host library { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) }, { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") } -].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap); +].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap); var libraryTargets = librarySourceMap.map(function (f) { return path.join(builtLocalDirectory, f.target); diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 4837b673132ef..51830c50bfee0 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -957,6 +957,9 @@ namespace ts { const postLoopLabel = createBranchLabel(); addAntecedent(preLoopLabel, currentFlow); currentFlow = preLoopLabel; + if (node.kind === SyntaxKind.ForOfStatement) { + bind(node.awaitModifier); + } bind(node.expression); addAntecedent(postLoopLabel, currentFlow); bind(node.initializer); @@ -2407,7 +2410,7 @@ namespace ts { function bindFunctionDeclaration(node: FunctionDeclaration) { if (!isDeclarationFile(file) && !isInAmbientContext(node)) { - if (isAsyncFunctionLike(node)) { + if (isAsyncFunction(node)) { emitFlags |= NodeFlags.HasAsyncFunctions; } } @@ -2424,7 +2427,7 @@ namespace ts { function bindFunctionExpression(node: FunctionExpression) { if (!isDeclarationFile(file) && !isInAmbientContext(node)) { - if (isAsyncFunctionLike(node)) { + if (isAsyncFunction(node)) { emitFlags |= NodeFlags.HasAsyncFunctions; } } @@ -2438,7 +2441,7 @@ namespace ts { function bindPropertyOrMethodOrAccessor(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags) { if (!isDeclarationFile(file) && !isInAmbientContext(node)) { - if (isAsyncFunctionLike(node)) { + if (isAsyncFunction(node)) { emitFlags |= NodeFlags.HasAsyncFunctions; } } @@ -2872,11 +2875,10 @@ namespace ts { // An async method declaration is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; } - // Currently, we only support generators that were originally async function bodies. - if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) { + if (node.asteriskToken) { transformFlags |= TransformFlags.AssertGenerator; } @@ -2942,7 +2944,7 @@ namespace ts { // An async function declaration is ES2017 syntax. if (modifierFlags & ModifierFlags.Async) { - transformFlags |= TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; } // function declarations with object rest destructuring are ES Next syntax @@ -2962,7 +2964,7 @@ namespace ts { // down-level generator. // Currently we do not support transforming any other generator fucntions // down level. - if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) { + if (node.asteriskToken) { transformFlags |= TransformFlags.AssertGenerator; } } @@ -2984,7 +2986,7 @@ namespace ts { // An async function expression is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; } // function expressions with object rest destructuring are ES Next syntax @@ -3003,9 +3005,7 @@ namespace ts { // If a FunctionExpression is generator function and is the body of a // transformed async function, then this node can be transformed to a // down-level generator. - // Currently we do not support transforming any other generator fucntions - // down level. - if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) { + if (node.asteriskToken) { transformFlags |= TransformFlags.AssertGenerator; } @@ -3173,8 +3173,8 @@ namespace ts { switch (kind) { case SyntaxKind.AsyncKeyword: case SyntaxKind.AwaitExpression: - // async/await is ES2017 syntax - transformFlags |= TransformFlags.AssertES2017; + // async/await is ES2017 syntax, but may be ESNext syntax (for async generators) + transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017; break; case SyntaxKind.PublicKeyword: @@ -3206,10 +3206,6 @@ namespace ts { transformFlags |= TransformFlags.AssertJsx; break; - case SyntaxKind.ForOfStatement: - // for-of might be ESNext if it has a rest destructuring - transformFlags |= TransformFlags.AssertESNext; - // FALLTHROUGH case SyntaxKind.NoSubstitutionTemplateLiteral: case SyntaxKind.TemplateHead: case SyntaxKind.TemplateMiddle: @@ -3223,9 +3219,18 @@ namespace ts { transformFlags |= TransformFlags.AssertES2015; break; + 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.AssertES2015; + break; + case SyntaxKind.YieldExpression: - // This node is ES6 syntax. - transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsYield; + // This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async + // generator). + transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield; break; case SyntaxKind.AnyKeyword: diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b4fe921be1f5d..5236e48205063 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -52,7 +52,7 @@ namespace ts { const emptySymbols = createMap(); const compilerOptions = host.getCompilerOptions(); - const languageVersion = compilerOptions.target || ScriptTarget.ES3; + const languageVersion = getEmitScriptTarget(compilerOptions); const modulekind = getEmitModuleKind(compilerOptions); const noUnusedIdentifiers = !!compilerOptions.noUnusedLocals || !!compilerOptions.noUnusedParameters; const allowSyntheticDefaultImports = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System; @@ -186,11 +186,6 @@ namespace ts { */ let patternAmbientModules: PatternAmbientModule[]; - let getGlobalESSymbolConstructorSymbol: () => Symbol; - - let getGlobalPromiseConstructorSymbol: () => Symbol; - let tryGetGlobalPromiseConstructorSymbol: () => Symbol; - let globalObjectType: ObjectType; let globalFunctionType: ObjectType; let globalArrayType: GenericType; @@ -206,26 +201,20 @@ namespace ts { // The library files are only loaded when the feature is used. // This allows users to just specify library files they want to used through --lib // and they will not get an error from not having unrelated library files - let getGlobalTemplateStringsArrayType: () => ObjectType; - - let getGlobalESSymbolType: () => ObjectType; - let getGlobalIterableType: () => GenericType; - let getGlobalIteratorType: () => GenericType; - let getGlobalIterableIteratorType: () => GenericType; - - let getGlobalClassDecoratorType: () => ObjectType; - let getGlobalParameterDecoratorType: () => ObjectType; - let getGlobalPropertyDecoratorType: () => ObjectType; - let getGlobalMethodDecoratorType: () => ObjectType; - let getGlobalTypedPropertyDescriptorType: () => ObjectType; - let getGlobalPromiseType: () => ObjectType; - let tryGetGlobalPromiseType: () => ObjectType; - let getGlobalPromiseLikeType: () => ObjectType; - let getInstantiatedGlobalPromiseLikeType: () => ObjectType; - let getGlobalPromiseConstructorLikeType: () => ObjectType; - let getGlobalThenableType: () => ObjectType; - - let jsxElementClassType: Type; + let deferredGlobalESSymbolConstructorSymbol: Symbol; + let deferredGlobalESSymbolType: ObjectType; + let deferredGlobalTypedPropertyDescriptorType: GenericType; + let deferredGlobalPromiseType: GenericType; + let deferredGlobalPromiseConstructorSymbol: Symbol; + let deferredGlobalPromiseConstructorLikeType: ObjectType; + let deferredGlobalIterableType: GenericType; + let deferredGlobalIteratorType: GenericType; + let deferredGlobalIterableIteratorType: GenericType; + let deferredGlobalAsyncIterableType: GenericType; + let deferredGlobalAsyncIteratorType: GenericType; + let deferredGlobalAsyncIterableIteratorType: GenericType; + let deferredGlobalTemplateStringsArrayType: ObjectType; + let deferredJsxElementClassType: Type; let deferredNodes: Node[]; let deferredUnusedIdentifierNodes: Node[]; @@ -3247,7 +3236,7 @@ namespace ts { // This elementType will be used if the specific property corresponding to this index is not // present (aka the tuple element property). This call also checks that the parentType is in // fact an iterable or array (depending on target language). - const elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false); + const elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false, /*allowAsyncIterable*/ false); if (declaration.dotDotDotToken) { // Rest element has an array type with the same element type as the parent type type = createArrayType(elementType); @@ -3335,7 +3324,8 @@ namespace ts { // missing properties/signatures required to get its iteratedType (like // [Symbol.iterator] or next). This may be because we accessed properties from anyType, // or it may have led to an error inside getElementTypeOfIterable. - return checkRightHandSideOfForOf((declaration.parent.parent).expression) || anyType; + const forOfStatement = declaration.parent.parent; + return checkRightHandSideOfForOf(forOfStatement.expression, forOfStatement.awaitModifier) || anyType; } if (isBindingPattern(declaration.parent)) { @@ -3794,6 +3784,13 @@ namespace ts { return unknownType; } + function isReferenceToType(type: Type, target: Type) { + return type !== undefined + && target !== undefined + && (getObjectFlags(type) & ObjectFlags.Reference) !== 0 + && (type).target === target; + } + function getTargetType(type: Type): Type { return getObjectFlags(type) & ObjectFlags.Reference ? (type).target : type; } @@ -5019,7 +5016,7 @@ namespace ts { t.flags & TypeFlags.StringLike ? globalStringType : t.flags & TypeFlags.NumberLike ? globalNumberType : t.flags & TypeFlags.BooleanLike ? globalBooleanType : - t.flags & TypeFlags.ESSymbol ? getGlobalESSymbolType() : + t.flags & TypeFlags.ESSymbol ? getGlobalESSymbolType(/*reportErrors*/ languageVersion >= ScriptTarget.ES2015) : t.flags & TypeFlags.NonPrimitive ? emptyObjectType : t; } @@ -5909,20 +5906,75 @@ namespace ts { return type; } - function getGlobalValueSymbol(name: string): Symbol { - return getGlobalSymbol(name, SymbolFlags.Value, Diagnostics.Cannot_find_global_value_0); + function getGlobalValueSymbol(name: string, reportErrors: boolean): Symbol { + return getGlobalSymbol(name, SymbolFlags.Value, reportErrors ? Diagnostics.Cannot_find_global_value_0 : undefined); } - function getGlobalTypeSymbol(name: string): Symbol { - return getGlobalSymbol(name, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0); + function getGlobalTypeSymbol(name: string, reportErrors: boolean): Symbol { + return getGlobalSymbol(name, SymbolFlags.Type, reportErrors ? Diagnostics.Cannot_find_global_type_0 : undefined); } function getGlobalSymbol(name: string, meaning: SymbolFlags, diagnostic: DiagnosticMessage): Symbol { return resolveName(undefined, name, meaning, diagnostic, name); } - function getGlobalType(name: string, arity = 0): ObjectType { - return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); + function getGlobalType(name: string, arity: 0, reportErrors: boolean): ObjectType; + function getGlobalType(name: string, arity: number, reportErrors: boolean): GenericType; + function getGlobalType(name: string, arity: number, reportErrors: boolean): ObjectType { + const symbol = getGlobalTypeSymbol(name, reportErrors); + return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined; + } + + function getGlobalTypedPropertyDescriptorType() { + return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType("TypedPropertyDescriptor", /*arity*/ 1, /*reportErrors*/ true)) || emptyGenericType; + } + + function getGlobalTemplateStringsArrayType() { + return deferredGlobalTemplateStringsArrayType || (deferredGlobalTemplateStringsArrayType = getGlobalType("TemplateStringsArray", /*arity*/ 0, /*reportErrors*/ true)) || emptyObjectType; + } + + function getGlobalESSymbolConstructorSymbol(reportErrors: boolean) { + return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors)); + } + + function getGlobalESSymbolType(reportErrors: boolean) { + return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", /*arity*/ 0, reportErrors)) || emptyObjectType; + } + + function getGlobalPromiseType(reportErrors: boolean) { + return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalPromiseConstructorSymbol(reportErrors: boolean): Symbol | undefined { + return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors)); + } + + function getGlobalPromiseConstructorLikeType(reportErrors: boolean) { + return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", /*arity*/ 0, reportErrors)) || emptyObjectType; + } + + function getGlobalAsyncIterableType(reportErrors: boolean) { + return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalAsyncIteratorType(reportErrors: boolean) { + return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalAsyncIterableIteratorType(reportErrors: boolean) { + return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalIterableType(reportErrors: boolean) { + return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalIteratorType(reportErrors: boolean) { + return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", /*arity*/ 1, reportErrors)) || emptyGenericType; + } + + function getGlobalIterableIteratorType(reportErrors: boolean) { + return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", /*arity*/ 1, reportErrors)) || emptyGenericType; } /** @@ -5935,16 +5987,6 @@ namespace ts { return typeSymbol && getDeclaredTypeOfSymbol(typeSymbol); } - /** - * Creates a TypeReference for a generic `TypedPropertyDescriptor`. - */ - function createTypedPropertyDescriptorType(propertyType: Type): Type { - const globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); - return globalTypedPropertyDescriptorType !== emptyGenericType - ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) - : emptyObjectType; - } - /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ @@ -5952,12 +5994,24 @@ namespace ts { return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType; } - function createIterableType(elementType: Type): Type { - return createTypeFromGenericGlobalType(getGlobalIterableType(), [elementType]); + function createTypedPropertyDescriptorType(propertyType: Type): Type { + return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]); + } + + function createAsyncIterableType(iteratedType: Type): Type { + return createTypeFromGenericGlobalType(getGlobalAsyncIterableType(/*reportErrors*/ true), [iteratedType]); } - function createIterableIteratorType(elementType: Type): Type { - return createTypeFromGenericGlobalType(getGlobalIterableIteratorType(), [elementType]); + function createAsyncIterableIteratorType(iteratedType: Type): Type { + return createTypeFromGenericGlobalType(getGlobalAsyncIterableIteratorType(/*reportErrors*/ true), [iteratedType]); + } + + function createIterableType(iteratedType: Type): Type { + return createTypeFromGenericGlobalType(getGlobalIterableType(/*reportErrors*/ true), [iteratedType]); + } + + function createIterableIteratorType(iteratedType: Type): Type { + return createTypeFromGenericGlobalType(getGlobalIterableIteratorType(/*reportErrors*/ true), [iteratedType]); } function createArrayType(elementType: Type): ObjectType { @@ -7600,7 +7654,7 @@ namespace ts { if ((globalStringType === source && stringType === target) || (globalNumberType === source && numberType === target) || (globalBooleanType === source && booleanType === target) || - (getGlobalESSymbolType() === source && esSymbolType === target)) { + (getGlobalESSymbolType(/*reportErrors*/ false) === source && esSymbolType === target)) { reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType); } } @@ -9720,12 +9774,12 @@ namespace ts { function getTypeOfDestructuredArrayElement(type: Type, index: number) { return isTupleLikeType(type) && getTypeOfPropertyOfType(type, "" + index) || - checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) || + checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterable*/ false) || unknownType; } function getTypeOfDestructuredSpreadExpression(type: Type) { - return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) || unknownType); + return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterable*/ false) || unknownType); } function getAssignedTypeOfBinaryExpression(node: BinaryExpression): Type { @@ -9764,7 +9818,7 @@ namespace ts { case SyntaxKind.ForInStatement: return stringType; case SyntaxKind.ForOfStatement: - return checkRightHandSideOfForOf((parent).expression) || unknownType; + return checkRightHandSideOfForOf((parent).expression, (parent).awaitModifier) || unknownType; case SyntaxKind.BinaryExpression: return getAssignedTypeOfBinaryExpression(parent); case SyntaxKind.DeleteExpression: @@ -9808,7 +9862,7 @@ namespace ts { return stringType; } if (node.parent.parent.kind === SyntaxKind.ForOfStatement) { - return checkRightHandSideOfForOf((node.parent.parent).expression) || unknownType; + return checkRightHandSideOfForOf((node.parent.parent).expression, (node.parent.parent).awaitModifier) || unknownType; } return unknownType; } @@ -10084,7 +10138,7 @@ namespace ts { } let type: FlowType; if (flow.flags & FlowFlags.AfterFinally) { - // block flow edge: finally -> pre-try (for larger explanation check comment in binder.ts - bindTryStatement + // block flow edge: finally -> pre-try (for larger explanation check comment in binder.ts - bindTryStatement (flow).locked = true; type = getTypeAtFlowNode((flow).antecedent); (flow).locked = false; @@ -10252,7 +10306,7 @@ namespace ts { let seenIncomplete = false; for (const antecedent of flow.antecedents) { if (antecedent.flags & FlowFlags.PreFinally && (antecedent).lock.locked) { - // if flow correspond to branch from pre-try to finally and this branch is locked - this means that + // if flow correspond to branch from pre-try to finally and this branch is locked - this means that // we initially have started following the flow outside the finally block. // in this case we should ignore this branch. continue; @@ -11444,31 +11498,29 @@ namespace ts { function getContextualTypeForReturnExpression(node: Expression): Type { const func = getContainingFunction(node); - - if (isAsyncFunctionLike(func)) { - const contextualReturnType = getContextualReturnType(func); - if (contextualReturnType) { - return getPromisedType(contextualReturnType); + if (func) { + const functionFlags = getFunctionFlags(func); + if (functionFlags & FunctionFlags.Generator) { // AsyncGenerator function or Generator function + return undefined; } - return undefined; - } - - if (func && !func.asteriskToken) { - return getContextualReturnType(func); + const contextualReturnType = getContextualReturnType(func); + return functionFlags & FunctionFlags.Async + ? contextualReturnType && getAwaitedTypeOfPromise(contextualReturnType) // Async function + : contextualReturnType; // Regular function } - return undefined; } function getContextualTypeForYieldOperand(node: YieldExpression): Type { const func = getContainingFunction(node); if (func) { + const functionFlags = getFunctionFlags(func); const contextualReturnType = getContextualReturnType(func); if (contextualReturnType) { return node.asteriskToken ? contextualReturnType - : getElementTypeOfIterableIterator(contextualReturnType); + : getIteratedTypeOfGenerator(contextualReturnType, (functionFlags & FunctionFlags.Async) !== 0); } } @@ -11646,7 +11698,7 @@ namespace ts { const index = indexOf(arrayLiteral.elements, node); return getTypeOfPropertyOfContextualType(type, "" + index) || getIndexTypeOfContextualType(type, IndexKind.Number) - || (languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined); + || getIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterable*/ false, /*checkAssignability*/ false); } return undefined; } @@ -11861,8 +11913,12 @@ namespace ts { } function checkSpreadExpression(node: SpreadElement, contextualMapper?: TypeMapper): Type { + if (languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.SpreadIncludes); + } + const arrayOrIterableType = checkExpression(node.expression, contextualMapper); - return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false); + return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false, /*allowAsyncIterable*/ false); } function hasDefaultValue(node: BindingElement | Expression): boolean { @@ -11891,7 +11947,7 @@ namespace ts { // if there is no index type / iterated type. const restArrayType = checkExpression((e).expression, contextualMapper); const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) || - (languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined); + getIteratedTypeOrElementType(restArrayType, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterable*/ false, /*checkAssignability*/ false); if (restElementType) { elementTypes.push(restElementType); } @@ -12575,7 +12631,7 @@ namespace ts { // If the elemType is a stringLiteral type, we can then provide a check to make sure that the string literal type is one of the Jsx intrinsic element type // For example: // var CustomTag: "h1" = "h1"; - // Hello World + // Hello World const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements); if (intrinsicElementsType !== unknownType) { const stringLiteralTypeName = (elementType).text; @@ -12721,7 +12777,7 @@ namespace ts { } /** - * Get the attributes type, which indicates the attributes that are valid on the given JSXOpeningLikeElement. + * Get the attributes type, which indicates the attributes that are valid on the given JSXOpeningLikeElement. * @param node a JSXOpeningLikeElement node * @return an attributes type of the given node */ @@ -12746,10 +12802,10 @@ namespace ts { } function getJsxGlobalElementClassType(): Type { - if (!jsxElementClassType) { - jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); + if (!deferredJsxElementClassType) { + deferredJsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); } - return jsxElementClassType; + return deferredJsxElementClassType; } /** @@ -13215,7 +13271,7 @@ namespace ts { return false; } - const globalESSymbol = getGlobalESSymbolConstructorSymbol(); + const globalESSymbol = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ true); if (!globalESSymbol) { // Already errored when we tried to look up the symbol return false; @@ -13534,7 +13590,7 @@ namespace ts { */ function checkApplicableSignatureForJsxOpeningLikeElement(node: JsxOpeningLikeElement, signature: Signature, relation: Map) { // JSX opening-like element has correct arity for stateless-function component if the one of the following condition is true: - // 1. callIsIncomplete + // 1. callIsIncomplete // 2. attributes property has same number of properties as the parameter object type. // We can figure that out by resolving attributes property and check number of properties in the resolved type // If the call has correct arity, we will then check if the argument type and parameter type is assignable @@ -14691,6 +14747,10 @@ namespace ts { pos < signature.parameters.length ? getTypeOfParameter(signature.parameters[pos]) : anyType; } + function getTypeOfFirstParameterOfSignature(signature: Signature) { + return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : neverType; + } + function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) { const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0); if (isInferentialContext(mapper)) { @@ -14798,10 +14858,10 @@ namespace ts { function createPromiseType(promisedType: Type): Type { // creates a `Promise` type where `T` is the promisedType argument - const globalPromiseType = getGlobalPromiseType(); + const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true); if (globalPromiseType !== emptyGenericType) { // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type - promisedType = getAwaitedType(promisedType); + promisedType = getAwaitedType(promisedType) || emptyObjectType; return createTypeReference(globalPromiseType, [promisedType]); } @@ -14814,7 +14874,7 @@ namespace ts { error(func, Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option); return unknownType; } - else if (!getGlobalPromiseConstructorSymbol()) { + else if (!getGlobalPromiseConstructorSymbol(/*reportErrors*/ true)) { error(func, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); } @@ -14827,25 +14887,26 @@ namespace ts { return unknownType; } - const isAsync = isAsyncFunctionLike(func); + const functionFlags = getFunctionFlags(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { type = checkExpressionCached(func.body, contextualMapper); - if (isAsync) { + if (functionFlags & FunctionFlags.Async) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which we will wrap in // the native Promise type later in this function. - type = checkAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, /*errorNode*/ func); } } else { let types: Type[]; - const funcIsGenerator = !!func.asteriskToken; - if (funcIsGenerator) { + if (functionFlags & FunctionFlags.Generator) { // Generator or AsyncGenerator function types = checkAndAggregateYieldOperandTypes(func, contextualMapper); if (types.length === 0) { - const iterableIteratorAny = createIterableIteratorType(anyType); + const iterableIteratorAny = functionFlags & FunctionFlags.Async + ? createAsyncIterableIteratorType(anyType) // AsyncGenerator function + : createIterableIteratorType(anyType); // Generator function if (compilerOptions.noImplicitAny) { error(func.asteriskToken, Diagnostics.Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type, typeToString(iterableIteratorAny)); @@ -14857,23 +14918,31 @@ namespace ts { types = checkAndAggregateReturnExpressionTypes(func, contextualMapper); if (!types) { // For an async function, the return type will not be never, but rather a Promise for never. - return isAsync ? createPromiseReturnType(func, neverType) : neverType; + return functionFlags & FunctionFlags.Async + ? createPromiseReturnType(func, neverType) // Async function + : neverType; // Normal function } if (types.length === 0) { // For an async function, the return type will not be void, but rather a Promise for void. - return isAsync ? createPromiseReturnType(func, voidType) : voidType; + return functionFlags & FunctionFlags.Async + ? createPromiseReturnType(func, voidType) // Async function + : voidType; // Normal function } } // Return a union of the return expression types. type = getUnionType(types, /*subtypeReduction*/ true); - if (funcIsGenerator) { - type = createIterableIteratorType(type); + if (functionFlags & FunctionFlags.Generator) { // AsyncGenerator function or Generator function + type = functionFlags & FunctionFlags.Async + ? createAsyncIterableIteratorType(type) // AsyncGenerator function + : createIterableIteratorType(type); // Generator function } } + if (!contextualSignature) { reportErrorsFromWidening(func, type); } + if (isUnitType(type) && !(contextualSignature && isLiteralContextualType( @@ -14885,22 +14954,22 @@ namespace ts { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body is awaited type of the body, wrapped in a native Promise type. - return isAsync ? createPromiseReturnType(func, widenedType) : widenedType; + return (functionFlags & FunctionFlags.AsyncOrAsyncGenerator) === FunctionFlags.Async + ? createPromiseReturnType(func, widenedType) // Async function + : widenedType; // Generator function, AsyncGenerator function, or normal function } function checkAndAggregateYieldOperandTypes(func: FunctionLikeDeclaration, contextualMapper: TypeMapper): Type[] { const aggregatedTypes: Type[] = []; - + const functionFlags = getFunctionFlags(func); forEachYieldExpression(func.body, yieldExpression => { const expr = yieldExpression.expression; if (expr) { let type = checkExpressionCached(expr, contextualMapper); - if (yieldExpression.asteriskToken) { // A yield* expression effectively yields everything that its operand yields - type = checkElementTypeOfIterable(type, yieldExpression.expression); + type = checkIteratedTypeOrElementType(type, yieldExpression.expression, /*allowStringInput*/ false, (functionFlags & FunctionFlags.Async) !== 0); } - if (!contains(aggregatedTypes, type)) { aggregatedTypes.push(type); } @@ -14937,7 +15006,7 @@ namespace ts { } function checkAndAggregateReturnExpressionTypes(func: FunctionLikeDeclaration, contextualMapper: TypeMapper): Type[] { - const isAsync = isAsyncFunctionLike(func); + const functionFlags = getFunctionFlags(func); const aggregatedTypes: Type[] = []; let hasReturnWithNoExpression = functionHasImplicitReturn(func); let hasReturnOfTypeNever = false; @@ -14945,12 +15014,12 @@ namespace ts { const expr = returnStatement.expression; if (expr) { let type = checkExpressionCached(expr, contextualMapper); - if (isAsync) { + if (functionFlags & FunctionFlags.Async) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which should be wrapped in // the native Promise type by the caller. - type = checkAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, func); } if (type.flags & TypeFlags.Never) { hasReturnOfTypeNever = true; @@ -15094,9 +15163,13 @@ namespace ts { function checkFunctionExpressionOrObjectLiteralMethodDeferred(node: ArrowFunction | FunctionExpression | MethodDeclaration) { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); - const isAsync = isAsyncFunctionLike(node); - const returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type)); - if (!node.asteriskToken) { + const functionFlags = getFunctionFlags(node); + const returnOrPromisedType = node.type && + ((functionFlags & FunctionFlags.AsyncOrAsyncGenerator) === FunctionFlags.Async ? + checkAsyncFunctionReturnType(node) : // Async function + getTypeFromTypeNode(node.type)); // AsyncGenerator function, Generator function, or normal function + + if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function // return is not necessary in the body of generators checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType); } @@ -15122,11 +15195,11 @@ namespace ts { // its return type annotation. const exprType = checkExpression(node.body); if (returnOrPromisedType) { - if (isAsync) { - const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member); + if ((functionFlags & FunctionFlags.AsyncOrAsyncGenerator) === FunctionFlags.Async) { // Async function + const awaitedType = checkAwaitedType(exprType, node.body); checkTypeAssignableTo(awaitedType, returnOrPromisedType, node.body); } - else { + else { // Normal function checkTypeAssignableTo(exprType, returnOrPromisedType, node.body); } } @@ -15441,10 +15514,14 @@ namespace ts { } function checkArrayLiteralAssignment(node: ArrayLiteralExpression, sourceType: Type, contextualMapper?: TypeMapper): Type { + if (languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.Read); + } + // This elementType will be used if the specific property corresponding to this index is not // present (aka the tuple element property). This call also checks that the parentType is in // fact an iterable or array (depending on target language). - const elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false) || unknownType; + const elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false, /*allowAsyncIterable*/ false) || unknownType; const elements = node.elements; for (let i = 0; i < elements.length; i++) { checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, elementType, contextualMapper); @@ -15852,18 +15929,31 @@ namespace ts { const func = getContainingFunction(node); // If the user's code is syntactically correct, the func should always have a star. After all, // we are in a yield context. - if (func && func.asteriskToken) { + const functionFlags = func && getFunctionFlags(func); + if (node.asteriskToken) { + if (functionFlags & FunctionFlags.Async) { + if (languageVersion < ScriptTarget.ES2017) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.AsyncDelegator); + } + } + else if (languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.Values); + } + } + + if (functionFlags & FunctionFlags.Generator) { const expressionType = checkExpressionCached(node.expression, /*contextualMapper*/ undefined); let expressionElementType: Type; const nodeIsYieldStar = !!node.asteriskToken; if (nodeIsYieldStar) { - expressionElementType = checkElementTypeOfIterable(expressionType, node.expression); + expressionElementType = checkIteratedTypeOrElementType(expressionType, node.expression, /*allowStringInput*/ false, (functionFlags & FunctionFlags.Async) !== 0); } + // There is no point in doing an assignability check if the function // has no explicit return type because the return type is directly computed // from the yield expressions. if (func.type) { - const signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType; + const signatureElementType = getIteratedTypeOfGenerator(getTypeFromTypeNode(func.type), (functionFlags & FunctionFlags.Async) !== 0) || anyType; if (nodeIsYieldStar) { checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined); } @@ -16209,16 +16299,6 @@ namespace ts { } } - function isSyntacticallyValidGenerator(node: SignatureDeclaration): boolean { - if (!(node).asteriskToken || !(node).body) { - return false; - } - - return node.kind === SyntaxKind.MethodDeclaration || - node.kind === SyntaxKind.FunctionDeclaration || - node.kind === SyntaxKind.FunctionExpression; - } - function getTypePredicateParameterIndex(parameterList: NodeArray, parameter: Identifier): number { if (parameterList) { for (let i = 0; i < parameterList.length; i++) { @@ -16338,13 +16418,23 @@ namespace ts { checkGrammarFunctionLikeDeclaration(node); } - if (isAsyncFunctionLike(node) && languageVersion < ScriptTarget.ES2017) { + const functionFlags = getFunctionFlags(node); + if ((functionFlags & FunctionFlags.InvalidAsyncOrAsyncGenerator) === FunctionFlags.Async && languageVersion < ScriptTarget.ES2017) { checkExternalEmitHelpers(node, ExternalEmitHelpers.Awaiter); if (languageVersion < ScriptTarget.ES2015) { checkExternalEmitHelpers(node, ExternalEmitHelpers.Generator); } } + if ((functionFlags & FunctionFlags.InvalidGenerator) === FunctionFlags.Generator) { + if (functionFlags & FunctionFlags.Async && languageVersion < ScriptTarget.ES2017) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.AsyncGenerator); + } + else if (languageVersion < ScriptTarget.ES2015) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.Generator); + } + } + checkTypeParameters(node.typeParameters); forEach(node.parameters, checkParameter); @@ -16367,14 +16457,17 @@ namespace ts { } if (node.type) { - if (languageVersion >= ScriptTarget.ES2015 && isSyntacticallyValidGenerator(node)) { + const functionFlags = getFunctionFlags(node); + if ((functionFlags & FunctionFlags.InvalidGenerator) === FunctionFlags.Generator) { const returnType = getTypeFromTypeNode(node.type); if (returnType === voidType) { error(node.type, Diagnostics.A_generator_cannot_have_a_void_type_annotation); } else { - const generatorElementType = getElementTypeOfIterableIterator(returnType) || anyType; - const iterableIteratorInstantiation = createIterableIteratorType(generatorElementType); + const generatorElementType = getIteratedTypeOfGenerator(returnType, (functionFlags & FunctionFlags.Async) !== 0) || anyType; + const iterableIteratorInstantiation = functionFlags & FunctionFlags.Async + ? createAsyncIterableIteratorType(generatorElementType) // AsyncGenerator function + : createIterableIteratorType(generatorElementType); // Generator function // Naively, one could check that IterableIterator is assignable to the return type annotation. // However, that would not catch the error in the following case. @@ -16385,7 +16478,7 @@ namespace ts { checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type); } } - else if (isAsyncFunctionLike(node)) { + else if ((functionFlags & FunctionFlags.AsyncOrAsyncGenerator) === FunctionFlags.Async) { checkAsyncFunctionReturnType(node); } } @@ -17186,22 +17279,9 @@ namespace ts { } } - function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage): Type { - type = getWidenedType(type); - const apparentType = getApparentType(type); - if ((apparentType.flags & (TypeFlags.Any | TypeFlags.Never)) === 0 && isTypeAssignableTo(type, getGlobalThenableType())) { - if (location) { - if (!message) { - message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; - } - - error(location, message); - } - - return unknownType; - } - - return type; + function getAwaitedTypeOfPromise(type: Type, errorNode?: Node): Type | undefined { + const promisedType = getPromisedTypeOfPromise(type, errorNode); + return promisedType && getAwaitedType(promisedType, errorNode); } /** @@ -17209,7 +17289,7 @@ namespace ts { * @param type The type of the promise. * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback. */ - function getPromisedType(promise: Type): Type { + function getPromisedTypeOfPromise(promise: Type, errorNode?: Node): Type { // // { // promise // then( // thenFunction @@ -17224,25 +17304,25 @@ namespace ts { return undefined; } - if (getObjectFlags(promise) & ObjectFlags.Reference) { - if ((promise).target === tryGetGlobalPromiseType() - || (promise).target === getGlobalPromiseLikeType()) { - return (promise).typeArguments[0]; - } + const typeAsPromise = promise; + if (typeAsPromise.promisedTypeOfPromise) { + return typeAsPromise.promisedTypeOfPromise; } - const globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); - if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) { - return undefined; + if (isReferenceToType(promise, getGlobalPromiseType(/*reportErrors*/ false))) { + return typeAsPromise.promisedTypeOfPromise = (promise).typeArguments[0]; } const thenFunction = getTypeOfPropertyOfType(promise, "then"); - if (!thenFunction || isTypeAny(thenFunction)) { + if (isTypeAny(thenFunction)) { return undefined; } - const thenSignatures = getSignaturesOfType(thenFunction, SignatureKind.Call); + const thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray; if (thenSignatures.length === 0) { + if (errorNode) { + error(errorNode, Diagnostics.A_promise_must_have_a_then_method); + } return undefined; } @@ -17253,14 +17333,13 @@ namespace ts { const onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); if (onfulfilledParameterSignatures.length === 0) { + if (errorNode) { + error(errorNode, Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback); + } return undefined; } - return getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), /*subtypeReduction*/ true); - } - - function getTypeOfFirstParameterOfSignature(signature: Signature) { - return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : neverType; + return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), /*subtypeReduction*/ true); } /** @@ -17270,96 +17349,111 @@ namespace ts { * Promise-like type; otherwise, it is the type of the expression. This is used to reflect * The runtime behavior of the `await` keyword. */ - function getAwaitedType(type: Type) { - return checkAwaitedType(type, /*location*/ undefined, /*message*/ undefined); + function checkAwaitedType(type: Type, errorNode: Node): Type { + return getAwaitedType(type, errorNode) || unknownType; } - function checkAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage) { - return checkAwaitedTypeWorker(type); + function getAwaitedType(type: Type, errorNode?: Node): Type | undefined { + const typeAsAwaitable = type; + if (typeAsAwaitable.awaitedTypeOfType) { + return typeAsAwaitable.awaitedTypeOfType; + } - function checkAwaitedTypeWorker(type: Type): Type { - if (type.flags & TypeFlags.Union) { - const types: Type[] = []; - for (const constituentType of (type).types) { - types.push(checkAwaitedTypeWorker(constituentType)); - } + if (isTypeAny(type)) { + return typeAsAwaitable.awaitedTypeOfType = type; + } - return getUnionType(types, /*subtypeReduction*/ true); + if (type.flags & TypeFlags.Union) { + let types: Type[]; + for (const constituentType of (type).types) { + types = append(types, getAwaitedType(constituentType, errorNode)); } - else { - const promisedType = getPromisedType(type); - if (promisedType === undefined) { - // The type was not a PromiseLike, so it could not be unwrapped any further. - // As long as the type does not have a callable "then" property, it is - // safe to return the type; otherwise, an error will have been reported in - // the call to checkNonThenableType and we will return unknownType. - // - // An example of a non-promise "thenable" might be: - // - // await { then(): void {} } - // - // The "thenable" does not match the minimal definition for a PromiseLike. When - // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise - // will never settle. We treat this as an error to help flag an early indicator - // of a runtime problem. If the user wants to return this value from an async - // function, they would need to wrap it in some other value. If they want it to - // be treated as a promise, they can cast to . - return checkNonThenableType(type, location, message); - } - else { - if (type.id === promisedType.id || indexOf(awaitedTypeStack, promisedType.id) >= 0) { - // We have a bad actor in the form of a promise whose promised type is - // the same promise type, or a mutually recursive promise. Return the - // unknown type as we cannot guess the shape. If this were the actual - // case in the JavaScript, this Promise would never resolve. - // - // An example of a bad actor with a singly-recursive promise type might - // be: - // - // interface BadPromise { - // then( - // onfulfilled: (value: BadPromise) => any, - // onrejected: (error: any) => any): BadPromise; - // } - // - // The above interface will pass the PromiseLike check, and return a - // promised type of `BadPromise`. Since this is a self reference, we - // don't want to keep recursing ad infinitum. - // - // An example of a bad actor in the form of a mutually-recursive - // promise type might be: - // - // interface BadPromiseA { - // then( - // onfulfilled: (value: BadPromiseB) => any, - // onrejected: (error: any) => any): BadPromiseB; - // } - // - // interface BadPromiseB { - // then( - // onfulfilled: (value: BadPromiseA) => any, - // onrejected: (error: any) => any): BadPromiseA; - // } - // - if (location) { - error( - location, - Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, - symbolToString(type.symbol)); - } - return unknownType; - } + if (!types) { + return undefined; + } - // Keep track of the type we're about to unwrap to avoid bad recursive promise types. - // See the comments above for more information. - awaitedTypeStack.push(type.id); - const awaitedType = checkAwaitedTypeWorker(promisedType); - awaitedTypeStack.pop(); - return awaitedType; + return typeAsAwaitable.awaitedTypeOfType = getUnionType(types, /*subtypeReduction*/ true); + } + + const promisedType = getPromisedTypeOfPromise(type); + if (promisedType) { + if (type.id === promisedType.id || indexOf(awaitedTypeStack, promisedType.id) >= 0) { + // Verify that we don't have a bad actor in the form of a promise whose + // promised type is the same as the promise type, or a mutually recursive + // promise. If so, we return undefined as we cannot guess the shape. If this + // were the actual case in the JavaScript, this Promise would never resolve. + // + // An example of a bad actor with a singly-recursive promise type might + // be: + // + // interface BadPromise { + // then( + // onfulfilled: (value: BadPromise) => any, + // onrejected: (error: any) => any): BadPromise; + // } + // The above interface will pass the PromiseLike check, and return a + // promised type of `BadPromise`. Since this is a self reference, we + // don't want to keep recursing ad infinitum. + // + // An example of a bad actor in the form of a mutually-recursive + // promise type might be: + // + // interface BadPromiseA { + // then( + // onfulfilled: (value: BadPromiseB) => any, + // onrejected: (error: any) => any): BadPromiseB; + // } + // + // interface BadPromiseB { + // then( + // onfulfilled: (value: BadPromiseA) => any, + // onrejected: (error: any) => any): BadPromiseA; + // } + // + if (errorNode) { + error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); } + return undefined; } + + // Keep track of the type we're about to unwrap to avoid bad recursive promise types. + // See the comments above for more information. + awaitedTypeStack.push(type.id); + const awaitedType = getAwaitedType(promisedType, errorNode); + awaitedTypeStack.pop(); + + if (!awaitedType) { + return undefined; + } + + return typeAsAwaitable.awaitedTypeOfType = awaitedType; + } + + // The type was not a promise, so it could not be unwrapped any further. + // As long as the type does not have a callable "then" property, it is + // safe to return the type; otherwise, an error will be reported in + // the call to getNonThenableType and we will return undefined. + // + // An example of a non-promise "thenable" might be: + // + // await { then(): void {} } + // + // The "thenable" does not match the minimal definition for a promise. When + // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise + // will never settle. We treat this as an error to help flag an early indicator + // of a runtime problem. If the user wants to return this value from an async + // function, they would need to wrap it in some other value. If they want it to + // be treated as a promise, they can cast to . + const thenFunction = getTypeOfPropertyOfType(type, "then"); + if (thenFunction && getSignaturesOfType(thenFunction, SignatureKind.Call).length > 0) { + if (errorNode) { + error(errorNode, Diagnostics.Type_used_as_operand_to_await_or_the_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + return undefined; } + + return typeAsAwaitable.awaitedTypeOfType = type; } /** @@ -17406,8 +17500,8 @@ namespace ts { if (returnType === unknownType) { return unknownType; } - const globalPromiseType = getGlobalPromiseType(); - if (globalPromiseType !== emptyGenericType && globalPromiseType !== getTargetType(returnType)) { + const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true); + if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) { // The promise type was not a valid type reference to the global promise type, so we // report an error and return the unknown type. error(node.type, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type); @@ -17431,7 +17525,7 @@ namespace ts { const promiseConstructorSymbol = resolveEntityName(promiseConstructorName, SymbolFlags.Value, /*ignoreErrors*/ true); const promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : unknownType; if (promiseConstructorType === unknownType) { - if (promiseConstructorName.kind === SyntaxKind.Identifier && promiseConstructorName.text === "Promise" && getTargetType(returnType) === tryGetGlobalPromiseType()) { + if (promiseConstructorName.kind === SyntaxKind.Identifier && promiseConstructorName.text === "Promise" && getTargetType(returnType) === getGlobalPromiseType(/*reportErrors*/ false)) { error(node.type, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); } else { @@ -17440,7 +17534,7 @@ namespace ts { return unknownType; } - const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); + const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(/*reportErrors*/ true); if (globalPromiseConstructorLikeType === emptyObjectType) { // If we couldn't resolve the global PromiseConstructorLike type we cannot verify // compatibility with __awaiter. @@ -17465,7 +17559,7 @@ namespace ts { } // Get and return the awaited type of the return type. - return checkAwaitedType(returnType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return checkAwaitedType(returnType, node); } /** Check a decorator */ @@ -17611,7 +17705,7 @@ namespace ts { function checkFunctionOrMethodDeclaration(node: FunctionDeclaration | MethodDeclaration): void { checkDecorators(node); checkSignatureDeclaration(node); - const isAsync = isAsyncFunctionLike(node); + const functionFlags = getFunctionFlags(node); // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including @@ -17653,8 +17747,10 @@ namespace ts { checkSourceElement(node.body); - if (!node.asteriskToken) { - const returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type)); + if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function + const returnOrPromisedType = node.type && (functionFlags & FunctionFlags.Async + ? checkAsyncFunctionReturnType(node) // Async function + : getTypeFromTypeNode(node.type)); // normal function checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType); } @@ -17665,7 +17761,7 @@ namespace ts { reportImplicitAnyError(node, anyType); } - if (node.asteriskToken && nodeIsPresent(node.body)) { + if (functionFlags & FunctionFlags.Generator && nodeIsPresent(node.body)) { // A generator with a body and no type annotation can still cause errors. It can error if the // yielded values have no common supertype, or it can give an implicit any error if it has no // yielded values. The only way to trigger these errors is to try checking its return type. @@ -18162,7 +18258,7 @@ namespace ts { } if (node.kind === SyntaxKind.BindingElement) { - if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext && !isInAmbientContext(node)) { + if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext) { checkExternalEmitHelpers(node, ExternalEmitHelpers.Rest); } // check computed properties inside property names of binding elements @@ -18183,6 +18279,10 @@ namespace ts { // For a binding pattern, check contained binding elements if (isBindingPattern(node.name)) { + if (node.name.kind === SyntaxKind.ArrayBindingPattern && languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.Read); + } + forEach((node.name).elements, checkSourceElement); } // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body @@ -18276,10 +18376,10 @@ namespace ts { forEach(node.declarationList.declarations, checkSourceElement); } - function checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node: Node) { + function checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node: MethodDeclaration) { // We only disallow modifier on a method declaration if it is a property of object-literal-expression if (node.modifiers && node.parent.kind === SyntaxKind.ObjectLiteralExpression) { - if (isAsyncFunctionLike(node)) { + if (getFunctionFlags(node) & FunctionFlags.Async) { if (node.modifiers.length > 1) { return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); } @@ -18355,6 +18455,17 @@ namespace ts { function checkForOfStatement(node: ForOfStatement): void { checkGrammarForInOrForOfStatement(node); + if (node.kind === SyntaxKind.ForOfStatement) { + if ((node).awaitModifier) { + if (languageVersion < ScriptTarget.ES2017) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.ForAwaitOfIncludes); + } + } + else if (languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.ForOfIncludes); + } + } + // Check the LHS and RHS // If the LHS is a declaration, just check it as a variable declaration, which will in turn check the RHS // via checkRightHandSideOfForOf. @@ -18365,7 +18476,7 @@ namespace ts { } else { const varExpr = node.initializer; - const iteratedType = checkRightHandSideOfForOf(node.expression); + const iteratedType = checkRightHandSideOfForOf(node.expression, node.awaitModifier); // There may be a destructuring assignment on the left side if (varExpr.kind === SyntaxKind.ArrayLiteralExpression || varExpr.kind === SyntaxKind.ObjectLiteralExpression) { @@ -18451,56 +18562,126 @@ namespace ts { } } - function checkRightHandSideOfForOf(rhsExpression: Expression): Type { + function checkRightHandSideOfForOf(rhsExpression: Expression, awaitModifier: AwaitKeywordToken | undefined): Type { const expressionType = checkNonNullExpression(rhsExpression); - return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true); + return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true, awaitModifier !== undefined); } - function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean): Type { + function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean, allowAsyncIterable: boolean): Type { if (isTypeAny(inputType)) { return inputType; } - if (languageVersion >= ScriptTarget.ES2015) { - return checkElementTypeOfIterable(inputType, errorNode); + + return getIteratedTypeOrElementType(inputType, errorNode, allowStringInput, allowAsyncIterable, /*checkAssignability*/ true) || anyType; + } + + /** + * When consuming an iterable type in a for..of, spread, or iterator destructuring assignment + * we want to get the iterated type of an iterable for ES2015 or later, or the iterated type + * of a iterable (if defined globally) or element type of an array like for ES2015 or earlier. + */ + function getIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean, allowAsyncIterable: boolean, checkAssignability: boolean): Type { + const uplevelIteration = languageVersion >= ScriptTarget.ES2015; + const downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration; + + // Get the iterated type of an `Iterable` or `IterableIterator` only in ES2015 + // or higher, when inside of an async generator or for-await-if, or when + // downlevelIteration is requested. + if (uplevelIteration || downlevelIteration || allowAsyncIterable) { + // We only report errors for an invalid iterable type in ES2015 or higher. + const iteratedType = getIteratedTypeOfIterable(inputType, uplevelIteration ? errorNode : undefined, allowAsyncIterable, allowAsyncIterable, checkAssignability); + if (iteratedType || uplevelIteration) { + return iteratedType; + } } + + let arrayType = inputType; + let reportedError = false; + let hasStringConstituent = false; + + // If strings are permitted, remove any string-like constituents from the array type. + // This allows us to find other non-string element types from an array unioned with + // a string. if (allowStringInput) { - return checkElementTypeOfArrayOrString(inputType, errorNode); - } - if (isArrayLikeType(inputType)) { - const indexType = getIndexTypeOfType(inputType, IndexKind.Number); - if (indexType) { - return indexType; + if (arrayType.flags & TypeFlags.Union) { + // After we remove all types that are StringLike, we will know if there was a string constituent + // based on whether the result of filter is a new array. + const arrayTypes = (inputType).types; + const filteredTypes = filter(arrayTypes, t => !(t.flags & TypeFlags.StringLike)); + if (filteredTypes !== arrayTypes) { + arrayType = getUnionType(filteredTypes, /*subtypeReduction*/ true); + } + } + else if (arrayType.flags & TypeFlags.StringLike) { + arrayType = neverType; + } + + hasStringConstituent = arrayType !== inputType; + if (hasStringConstituent) { + if (languageVersion < ScriptTarget.ES5) { + if (errorNode) { + error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); + reportedError = true; + } + } + + // Now that we've removed all the StringLike types, if no constituents remain, then the entire + // arrayOrStringType was a string. + if (arrayType.flags & TypeFlags.Never) { + return stringType; + } } } - if (errorNode) { - error(errorNode, Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType)); + + if (!isArrayLikeType(arrayType)) { + if (errorNode && !reportedError) { + // Which error we report depends on whether we allow strings or if there was a + // string constituent. For example, if the input type is number | string, we + // want to say that number is not an array type. But if the input was just + // number and string input is allowed, we want to say that number is not an + // array type or a string type. + const diagnostic = !allowStringInput || hasStringConstituent + ? downlevelIteration + ? Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator + : Diagnostics.Type_0_is_not_an_array_type + : downlevelIteration + ? Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator + : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type; + error(errorNode, diagnostic, typeToString(arrayType)); + } + return hasStringConstituent ? stringType : undefined; } - return unknownType; - } - /** - * When errorNode is undefined, it means we should not report any errors. - */ - function checkElementTypeOfIterable(iterable: Type, errorNode: Node): Type { - const elementType = getElementTypeOfIterable(iterable, errorNode); - // Now even though we have extracted the iteratedType, we will have to validate that the type - // passed in is actually an Iterable. - if (errorNode && elementType) { - checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode); + const arrayElementType = getIndexTypeOfType(arrayType, IndexKind.Number); + if (hasStringConstituent && arrayElementType) { + // This is just an optimization for the case where arrayOrStringType is string | string[] + if (arrayElementType.flags & TypeFlags.StringLike) { + return stringType; + } + + return getUnionType([arrayElementType, stringType], /*subtypeReduction*/ true); } - return elementType || anyType; + return arrayElementType; } /** * We want to treat type as an iterable, and get the type it is an iterable of. The iterable * must have the following structure (annotated with the names of the variables below): * - * { // iterable - * [Symbol.iterator]: { // iteratorFunction - * (): Iterator + * { // iterable + * [Symbol.iterator]: { // iteratorMethod + * (): Iterator + * } + * } + * + * For an async iterable, we expect the following structure: + * + * { // iterable + * [Symbol.asyncIterator]: { // iteratorMethod + * (): AsyncIterator + * } * } - * } * * T is the type we are after. At every level that involves analyzing return types * of signatures, we union the return types of all the signatures. @@ -18512,187 +18693,190 @@ namespace ts { * caller requested it. Then the caller can decide what to do in the case where there is no iterated * type. This is different from returning anyType, because that would signify that we have matched the * whole pattern and that T (above) is 'any'. + * + * For a **for-of** statement, `yield*` (in a normal generator), spread, array + * destructuring, or normal generator we will only ever look for a `[Symbol.iterator]()` + * method. + * + * For an async generator we will only ever look at the `[Symbol.asyncIterator]()` method. + * + * For a **for-await-of** statement or a `yield*` in an async generator we will look for + * the `[Symbol.asyncIterator]()` method first, and then the `[Symbol.iterator]()` method. */ - function getElementTypeOfIterable(type: Type, errorNode: Node): Type { + function getIteratedTypeOfIterable(type: Type, errorNode: Node | undefined, isAsyncIterable: boolean, allowNonAsyncIterables: boolean, checkAssignability: boolean): Type | undefined { if (isTypeAny(type)) { return undefined; } const typeAsIterable = type; - if (!typeAsIterable.iterableElementType) { - // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable), - // then just grab its type argument. - if ((getObjectFlags(type) & ObjectFlags.Reference) && (type).target === getGlobalIterableType()) { - typeAsIterable.iterableElementType = (type).typeArguments[0]; + if (isAsyncIterable ? typeAsIterable.iteratedTypeOfAsyncIterable : typeAsIterable.iteratedTypeOfIterable) { + return isAsyncIterable ? typeAsIterable.iteratedTypeOfAsyncIterable : typeAsIterable.iteratedTypeOfIterable; + } + + if (isAsyncIterable) { + // As an optimization, if the type is an instantiation of the global `AsyncIterable` + // or the global `AsyncIterableIterator` then just grab its type argument. + if (isReferenceToType(type, getGlobalAsyncIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, getGlobalAsyncIterableIteratorType(/*reportErrors*/ false))) { + return typeAsIterable.iteratedTypeOfAsyncIterable = (type).typeArguments[0]; } - else { - const iteratorFunction = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator")); - if (isTypeAny(iteratorFunction)) { - return undefined; - } + } - const iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray; - if (iteratorFunctionSignatures.length === 0) { - if (errorNode) { - error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator); - } - return undefined; - } + if (!isAsyncIterable || allowNonAsyncIterables) { + // As an optimization, if the type is an instantiation of the global `Iterable` or + // `IterableIterator` then just grab its type argument. + if (isReferenceToType(type, getGlobalIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, getGlobalIterableIteratorType(/*reportErrors*/ false))) { + return isAsyncIterable + ? typeAsIterable.iteratedTypeOfAsyncIterable = (type).typeArguments[0] + : typeAsIterable.iteratedTypeOfIterable = (type).typeArguments[0]; + } + } - typeAsIterable.iterableElementType = getElementTypeOfIterator(getUnionType(map(iteratorFunctionSignatures, getReturnTypeOfSignature), /*subtypeReduction*/ true), errorNode); + let iteratorMethodSignatures: Signature[]; + let mayBeIterable = false; + if (isAsyncIterable) { + const iteratorMethod = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("asyncIterator")); + if (isTypeAny(iteratorMethod)) { + return undefined; + } + iteratorMethodSignatures = iteratorMethod && getSignaturesOfType(iteratorMethod, SignatureKind.Call); + } + + if (!isAsyncIterable || (allowNonAsyncIterables && !some(iteratorMethodSignatures))) { + const iteratorMethod = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator")); + if (isTypeAny(iteratorMethod)) { + return undefined; } + iteratorMethodSignatures = iteratorMethod && getSignaturesOfType(iteratorMethod, SignatureKind.Call); + mayBeIterable = true; } - return typeAsIterable.iterableElementType; + if (some(iteratorMethodSignatures)) { + const iteratorMethodReturnType = getUnionType(map(iteratorMethodSignatures, getReturnTypeOfSignature), /*subtypeReduction*/ true); + const iteratedType = getIteratedTypeOfIterator(iteratorMethodReturnType, errorNode, /*isAsyncIterator*/ false); + if (checkAssignability && errorNode && iteratedType) { + // If `checkAssignability` was specified, we were called from + // `checkIteratedTypeOrElementType`. As such, we need to validate that + // the type passed in is actually an Iterable. + checkTypeAssignableTo(type, mayBeIterable + ? createIterableType(iteratedType) + : createAsyncIterableType(iteratedType), errorNode); + } + return isAsyncIterable + ? typeAsIterable.iteratedTypeOfAsyncIterable = iteratedType + : typeAsIterable.iteratedTypeOfIterable = iteratedType; + } + + if (errorNode) { + error(errorNode, + isAsyncIterable + ? Diagnostics.Type_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator + : Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator); + } + + return undefined; } /** - * This function has very similar logic as getElementTypeOfIterable, except that it operates on + * This function has very similar logic as getIteratedTypeOfIterable, except that it operates on * Iterators instead of Iterables. Here is the structure: * * { // iterator - * next: { // iteratorNextFunction - * (): { // iteratorNextResult - * value: T // iteratorNextValue + * next: { // nextMethod + * (): { // nextResult + * value: T // nextValue * } * } * } * + * For an async iterator, we expect the following structure: + * + * { // iterator + * next: { // nextMethod + * (): PromiseLike<{ // nextResult + * value: T // nextValue + * }> + * } + * } */ - function getElementTypeOfIterator(type: Type, errorNode: Node): Type { + function getIteratedTypeOfIterator(type: Type, errorNode: Node | undefined, isAsyncIterator: boolean): Type | undefined { if (isTypeAny(type)) { return undefined; } const typeAsIterator = type; - if (!typeAsIterator.iteratorElementType) { - // As an optimization, if the type is instantiated directly using the globalIteratorType (Iterator), - // then just grab its type argument. - if ((getObjectFlags(type) & ObjectFlags.Reference) && (type).target === getGlobalIteratorType()) { - typeAsIterator.iteratorElementType = (type).typeArguments[0]; - } - else { - const iteratorNextFunction = getTypeOfPropertyOfType(type, "next"); - if (isTypeAny(iteratorNextFunction)) { - return undefined; - } - - const iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray; - if (iteratorNextFunctionSignatures.length === 0) { - if (errorNode) { - error(errorNode, Diagnostics.An_iterator_must_have_a_next_method); - } - return undefined; - } - - const iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature), /*subtypeReduction*/ true); - if (isTypeAny(iteratorNextResult)) { - return undefined; - } - - const iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value"); - if (!iteratorNextValue) { - if (errorNode) { - error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property); - } - return undefined; - } - - typeAsIterator.iteratorElementType = iteratorNextValue; - } + if (isAsyncIterator ? typeAsIterator.iteratedTypeOfAsyncIterator : typeAsIterator.iteratedTypeOfIterator) { + return isAsyncIterator ? typeAsIterator.iteratedTypeOfAsyncIterator : typeAsIterator.iteratedTypeOfIterator; } - return typeAsIterator.iteratorElementType; - } - - function getElementTypeOfIterableIterator(type: Type): Type { - if (isTypeAny(type)) { - return undefined; + // As an optimization, if the type is an instantiation of the global `Iterator` (for + // a non-async iterator) or the global `AsyncIterator` (for an async-iterator) then + // just grab its type argument. + const getIteratorType = isAsyncIterator ? getGlobalAsyncIteratorType : getGlobalIteratorType; + if (isReferenceToType(type, getIteratorType(/*reportErrors*/ false))) { + return isAsyncIterator + ? typeAsIterator.iteratedTypeOfAsyncIterator = (type).typeArguments[0] + : typeAsIterator.iteratedTypeOfIterator = (type).typeArguments[0]; } - // As an optimization, if the type is instantiated directly using the globalIterableIteratorType (IterableIterator), - // then just grab its type argument. - if ((getObjectFlags(type) & ObjectFlags.Reference) && (type).target === getGlobalIterableIteratorType()) { - return (type).typeArguments[0]; + // Both async and non-async iterators must have a `next` method. + const nextMethod = getTypeOfPropertyOfType(type, "next"); + if (isTypeAny(nextMethod)) { + return undefined; } - return getElementTypeOfIterable(type, /*errorNode*/ undefined) || - getElementTypeOfIterator(type, /*errorNode*/ undefined); - } - - /** - * This function does the following steps: - * 1. Break up arrayOrStringType (possibly a union) into its string constituents and array constituents. - * 2. Take the element types of the array constituents. - * 3. Return the union of the element types, and string if there was a string constituent. - * - * For example: - * string -> string - * number[] -> number - * string[] | number[] -> string | number - * string | number[] -> string | number - * string | string[] | number[] -> string | number - * - * It also errors if: - * 1. Some constituent is neither a string nor an array. - * 2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable). - */ - function checkElementTypeOfArrayOrString(arrayOrStringType: Type, errorNode: Node): Type { - Debug.assert(languageVersion < ScriptTarget.ES2015); - - let arrayType = arrayOrStringType; - if (arrayOrStringType.flags & TypeFlags.Union) { - // After we remove all types that are StringLike, we will know if there was a string constituent - // based on whether the result of filter is a new array. - const arrayTypes = (arrayOrStringType as UnionType).types; - const filteredTypes = filter(arrayTypes, t => !(t.flags & TypeFlags.StringLike)); - if (filteredTypes !== arrayTypes) { - arrayType = getUnionType(filteredTypes, /*subtypeReduction*/ true); + const nextMethodSignatures = nextMethod ? getSignaturesOfType(nextMethod, SignatureKind.Call) : emptyArray; + if (nextMethodSignatures.length === 0) { + if (errorNode) { + error(errorNode, isAsyncIterator + ? Diagnostics.An_async_iterator_must_have_a_next_method + : Diagnostics.An_iterator_must_have_a_next_method); } + return undefined; } - else if (arrayOrStringType.flags & TypeFlags.StringLike) { - arrayType = neverType; + + let nextResult = getUnionType(map(nextMethodSignatures, getReturnTypeOfSignature), /*subtypeReduction*/ true); + if (isTypeAny(nextResult)) { + return undefined; } - const hasStringConstituent = arrayOrStringType !== arrayType; - let reportedError = false; - if (hasStringConstituent) { - if (languageVersion < ScriptTarget.ES5) { - error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); - reportedError = true; - } - // Now that we've removed all the StringLike types, if no constituents remain, then the entire - // arrayOrStringType was a string. - if (arrayType.flags & TypeFlags.Never) { - return stringType; + // For an async iterator, we must get the awaited type of the return type. + if (isAsyncIterator) { + nextResult = getAwaitedTypeOfPromise(nextResult, errorNode); + if (isTypeAny(nextResult)) { + return undefined; } } - if (!isArrayLikeType(arrayType)) { - if (!reportedError) { - // Which error we report depends on whether there was a string constituent. For example, - // if the input type is number | string, we want to say that number is not an array type. - // But if the input was just number, we want to say that number is not an array type - // or a string type. - const diagnostic = hasStringConstituent - ? Diagnostics.Type_0_is_not_an_array_type - : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type; - error(errorNode, diagnostic, typeToString(arrayType)); + const nextValue = nextResult && getTypeOfPropertyOfType(nextResult, "value"); + if (!nextValue) { + if (errorNode) { + error(errorNode, isAsyncIterator + ? Diagnostics.The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property + : Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property); } - return hasStringConstituent ? stringType : unknownType; + return undefined; } - const arrayElementType = getIndexTypeOfType(arrayType, IndexKind.Number) || unknownType; - if (hasStringConstituent) { - // This is just an optimization for the case where arrayOrStringType is string | string[] - if (arrayElementType.flags & TypeFlags.StringLike) { - return stringType; - } + return isAsyncIterator + ? typeAsIterator.iteratedTypeOfAsyncIterator = nextValue + : typeAsIterator.iteratedTypeOfIterator = nextValue; + } - return getUnionType([arrayElementType, stringType], /*subtypeReduction*/ true); + /** + * A generator may have a return type of `Iterator`, `Iterable`, or + * `IterableIterator`. An async generator may have a return type of `AsyncIterator`, + * `AsyncIterable`, or `AsyncIterableIterator`. This function can be used to extract + * the iterated type from this return type for contextual typing and verifying signatures. + */ + function getIteratedTypeOfGenerator(returnType: Type, isAsyncGenerator: boolean): Type { + if (isTypeAny(returnType)) { + return undefined; } - return arrayElementType; + return getIteratedTypeOfIterable(returnType, /*errorNode*/ undefined, isAsyncGenerator, /*allowNonAsyncIterables*/ false, /*checkAssignability*/ false) + || getIteratedTypeOfIterator(returnType, /*errorNode*/ undefined, isAsyncGenerator); } function checkBreakOrContinueStatement(node: BreakOrContinueStatement) { @@ -18707,7 +18891,9 @@ namespace ts { } function isUnwrappedReturnTypeVoidOrAny(func: FunctionLikeDeclaration, returnType: Type): boolean { - const unwrappedReturnType = isAsyncFunctionLike(func) ? getPromisedType(returnType) : returnType; + const unwrappedReturnType = (getFunctionFlags(func) & FunctionFlags.AsyncOrAsyncGenerator) === FunctionFlags.Async + ? getPromisedTypeOfPromise(returnType) // Async function + : returnType; // AsyncGenerator function, Generator function, or normal function return unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, TypeFlags.Void | TypeFlags.Any); } @@ -18726,8 +18912,8 @@ namespace ts { const returnType = getReturnTypeOfSignature(signature); if (strictNullChecks || node.expression || returnType.flags & TypeFlags.Never) { const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType; - - if (func.asteriskToken) { + const functionFlags = getFunctionFlags(func); + if (functionFlags & FunctionFlags.Generator) { // AsyncGenerator function or Generator function // A generator does not need its return expressions checked against its return type. // Instead, the yield expressions are checked against the element type. // TODO: Check return expressions of generators when return type tracking is added @@ -18746,9 +18932,9 @@ namespace ts { } } else if (func.type || isGetAccessorWithAnnotatedSetAccessor(func)) { - if (isAsyncFunctionLike(func)) { - const promisedType = getPromisedType(returnType); - const awaitedType = checkAwaitedType(exprType, node, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + if (functionFlags & FunctionFlags.Async) { // Async function + const promisedType = getPromisedTypeOfPromise(returnType); + const awaitedType = checkAwaitedType(exprType, node); if (promisedType) { // If the function has a return type, but promisedType is // undefined, an error will be reported in checkAsyncFunctionReturnType @@ -19151,7 +19337,7 @@ namespace ts { const baseTypeNode = getClassExtendsHeritageClauseElement(node); if (baseTypeNode) { - if (languageVersion < ScriptTarget.ES2015 && !isInAmbientContext(node)) { + if (languageVersion < ScriptTarget.ES2015) { checkExternalEmitHelpers(baseTypeNode.parent, ExternalEmitHelpers.Extends); } @@ -20916,7 +21102,7 @@ namespace ts { // for ( { a } of elems) { // } if (expr.parent.kind === SyntaxKind.ForOfStatement) { - const iteratedType = checkRightHandSideOfForOf((expr.parent).expression); + const iteratedType = checkRightHandSideOfForOf((expr.parent).expression, (expr.parent).awaitModifier); return checkDestructuringAssignment(expr, iteratedType || unknownType); } // If this is from "for" initializer @@ -20935,7 +21121,7 @@ namespace ts { Debug.assert(expr.parent.kind === SyntaxKind.ArrayLiteralExpression); // [{ property1: p1, property2 }] = elems; const typeOfArrayLiteral = getTypeOfArrayLiteralOrObjectLiteralDestructuringAssignment(expr.parent); - const elementType = checkIteratedTypeOrElementType(typeOfArrayLiteral || unknownType, expr.parent, /*allowStringInput*/ false) || unknownType; + const elementType = checkIteratedTypeOrElementType(typeOfArrayLiteral || unknownType, expr.parent, /*allowStringInput*/ false, /*allowAsyncIterable*/ false) || unknownType; return checkArrayLiteralDestructuringElementAssignment(expr.parent, typeOfArrayLiteral, indexOf((expr.parent).elements, expr), elementType || unknownType); } @@ -21331,7 +21517,7 @@ namespace ts { // Resolve the symbol as a type so that we can provide a more useful hint for the type serializer. const typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location); if (valueSymbol && valueSymbol === typeSymbol) { - const globalPromiseSymbol = tryGetGlobalPromiseConstructorSymbol(); + const globalPromiseSymbol = getGlobalPromiseConstructorSymbol(/*reportErrors*/ false); if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) { return TypeReferenceSerializationKind.Promise; } @@ -21645,49 +21831,18 @@ namespace ts { addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0); getSymbolLinks(undefinedSymbol).type = undefinedWideningType; - getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments"); + getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments", /*arity*/ 0, /*reportErrors*/ true); getSymbolLinks(unknownSymbol).type = unknownType; // Initialize special types - globalArrayType = getGlobalType("Array", /*arity*/ 1); - globalObjectType = getGlobalType("Object"); - globalFunctionType = getGlobalType("Function"); - globalStringType = getGlobalType("String"); - globalNumberType = getGlobalType("Number"); - globalBooleanType = getGlobalType("Boolean"); - globalRegExpType = getGlobalType("RegExp"); - + globalArrayType = getGlobalType("Array", /*arity*/ 1, /*reportErrors*/ true); + globalObjectType = getGlobalType("Object", /*arity*/ 0, /*reportErrors*/ true); + globalFunctionType = getGlobalType("Function", /*arity*/ 0, /*reportErrors*/ true); + globalStringType = getGlobalType("String", /*arity*/ 0, /*reportErrors*/ true); + globalNumberType = getGlobalType("Number", /*arity*/ 0, /*reportErrors*/ true); + globalBooleanType = getGlobalType("Boolean", /*arity*/ 0, /*reportErrors*/ true); + globalRegExpType = getGlobalType("RegExp", /*arity*/ 0, /*reportErrors*/ true); jsxElementType = getExportedTypeFromNamespace("JSX", JsxNames.Element); - getGlobalClassDecoratorType = memoize(() => getGlobalType("ClassDecorator")); - getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); - getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); - getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator")); - getGlobalTypedPropertyDescriptorType = memoize(() => getGlobalType("TypedPropertyDescriptor", /*arity*/ 1)); - getGlobalESSymbolConstructorSymbol = memoize(() => getGlobalValueSymbol("Symbol")); - getGlobalPromiseType = memoize(() => getGlobalType("Promise", /*arity*/ 1)); - tryGetGlobalPromiseType = memoize(() => getGlobalSymbol("Promise", SymbolFlags.Type, /*diagnostic*/ undefined) && getGlobalPromiseType()); - getGlobalPromiseLikeType = memoize(() => getGlobalType("PromiseLike", /*arity*/ 1)); - getInstantiatedGlobalPromiseLikeType = memoize(createInstantiatedPromiseLikeType); - getGlobalPromiseConstructorSymbol = memoize(() => getGlobalValueSymbol("Promise")); - tryGetGlobalPromiseConstructorSymbol = memoize(() => getGlobalSymbol("Promise", SymbolFlags.Value, /*diagnostic*/ undefined) && getGlobalPromiseConstructorSymbol()); - getGlobalPromiseConstructorLikeType = memoize(() => getGlobalType("PromiseConstructorLike")); - getGlobalThenableType = memoize(createThenableType); - - getGlobalTemplateStringsArrayType = memoize(() => getGlobalType("TemplateStringsArray")); - - if (languageVersion >= ScriptTarget.ES2015) { - getGlobalESSymbolType = memoize(() => getGlobalType("Symbol")); - getGlobalIterableType = memoize(() => getGlobalType("Iterable", /*arity*/ 1)); - getGlobalIteratorType = memoize(() => getGlobalType("Iterator", /*arity*/ 1)); - getGlobalIterableIteratorType = memoize(() => getGlobalType("IterableIterator", /*arity*/ 1)); - } - else { - getGlobalESSymbolType = memoize(() => emptyObjectType); - getGlobalIterableType = memoize(() => emptyGenericType); - getGlobalIteratorType = memoize(() => emptyGenericType); - getGlobalIterableIteratorType = memoize(() => emptyGenericType); - } - anyArrayType = createArrayType(anyType); autoArrayType = createArrayType(autoType); @@ -21699,7 +21854,7 @@ namespace ts { function checkExternalEmitHelpers(location: Node, helpers: ExternalEmitHelpers) { if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) { const sourceFile = getSourceFileOfNode(location); - if (isEffectiveExternalModule(sourceFile, compilerOptions)) { + if (isEffectiveExternalModule(sourceFile, compilerOptions) && !isInAmbientContext(location)) { const helpersModule = resolveHelpersModule(sourceFile, location); if (helpersModule !== unknownSymbol) { const uncheckedHelpers = helpers & ~requestedExternalEmitHelpers; @@ -21728,6 +21883,13 @@ namespace ts { case ExternalEmitHelpers.Param: return "__param"; case ExternalEmitHelpers.Awaiter: return "__awaiter"; case ExternalEmitHelpers.Generator: return "__generator"; + case ExternalEmitHelpers.Values: return "__values"; + case ExternalEmitHelpers.Read: return "__read"; + case ExternalEmitHelpers.Spread: return "__spread"; + case ExternalEmitHelpers.AsyncGenerator: return "__asyncGenerator"; + case ExternalEmitHelpers.AsyncDelegator: return "__asyncDelegator"; + case ExternalEmitHelpers.AsyncValues: return "__asyncValues"; + default: Debug.fail("Unrecognized helper."); } } @@ -21738,29 +21900,6 @@ namespace ts { return externalHelpersModule; } - - function createInstantiatedPromiseLikeType(): ObjectType { - const promiseLikeType = getGlobalPromiseLikeType(); - if (promiseLikeType !== emptyGenericType) { - return createTypeReference(promiseLikeType, [anyType]); - } - - return emptyObjectType; - } - - function createThenableType() { - // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`. - const thenPropertySymbol = createSymbol(SymbolFlags.Property, "then"); - getSymbolLinks(thenPropertySymbol).type = globalFunctionType; - - const thenableType = createObjectType(ObjectFlags.Anonymous); - thenableType.properties = [thenPropertySymbol]; - thenableType.members = createSymbolTable(thenableType.properties); - thenableType.callSignatures = []; - thenableType.constructSignatures = []; - return thenableType; - } - // GRAMMAR CHECKING function checkGrammarDecorators(node: Node): boolean { if (!node.decorators) { @@ -22052,10 +22191,7 @@ namespace ts { case SyntaxKind.FunctionDeclaration: case SyntaxKind.FunctionExpression: case SyntaxKind.ArrowFunction: - if (!(node).asteriskToken) { - return false; - } - break; + return false; } return grammarErrorOnNode(asyncModifier, Diagnostics._0_modifier_cannot_be_used_here, "async"); @@ -22300,9 +22436,6 @@ namespace ts { if (!node.body) { return grammarErrorOnNode(node.asteriskToken, Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator); } - if (languageVersion < ScriptTarget.ES2015) { - return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher); - } } } @@ -22431,6 +22564,12 @@ namespace ts { return true; } + if (forInOrOfStatement.kind === SyntaxKind.ForOfStatement && forInOrOfStatement.awaitModifier) { + if ((forInOrOfStatement.flags & NodeFlags.AwaitContext) === NodeFlags.None) { + return grammarErrorOnNode(forInOrOfStatement.awaitModifier, Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator); + } + } + if (forInOrOfStatement.initializer.kind === SyntaxKind.VariableDeclarationList) { const variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index ebb6a9ec39f41..6b4e9ff590efc 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -333,6 +333,11 @@ namespace ts { type: "boolean", description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file }, + { + name: "downlevelIteration", + type: "boolean", + description: Diagnostics.Use_full_down_level_iteration_for_iterables_and_arrays_for_for_of_spread_and_destructuring_in_ES5_Slash3 + }, { name: "baseUrl", type: "string", @@ -418,6 +423,7 @@ namespace ts { "es7": "lib.es2016.d.ts", "es2016": "lib.es2016.d.ts", "es2017": "lib.es2017.d.ts", + "esnext": "lib.esnext.d.ts", // Host only "dom": "lib.dom.d.ts", "dom.iterable": "lib.dom.iterable.d.ts", @@ -437,6 +443,7 @@ namespace ts { "es2017.object": "lib.es2017.object.d.ts", "es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts", "es2017.string": "lib.es2017.string.d.ts", + "esnext.asynciterable": "lib.esnext.asynciterable.d.ts", }), }, description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index db4bf23d78583..6d45b53f7fe1b 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -175,15 +175,15 @@ "category": "Error", "code": 1057 }, - "Operand for 'await' does not have a valid callable 'then' member.": { + "Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member.": { "category": "Error", "code": 1058 }, - "Return expression in async function does not have a valid callable 'then' member.": { + "A promise must have a 'then' method.": { "category": "Error", "code": 1059 }, - "Expression body for async arrow function does not have a valid callable 'then' member.": { + "The first parameter of the 'then' method of a promise must be a callback.": { "category": "Error", "code": 1060 }, @@ -191,7 +191,7 @@ "category": "Error", "code": 1061 }, - "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method.": { + "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method.": { "category": "Error", "code": 1062 }, @@ -291,6 +291,10 @@ "category": "Error", "code": 1102 }, + "A 'for-await-of' statement is only allowed within an async function or async generator.": { + "category": "Error", + "code": 1103 + }, "A 'continue' statement can only be used within an enclosing iteration statement.": { "category": "Error", "code": 1104 @@ -1631,6 +1635,10 @@ "category": "Error", "code": 2503 }, + "Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator.": { + "category": "Error", + "code": 2504 + }, "A generator cannot have a 'void' type annotation.": { "category": "Error", "code": 2505 @@ -1687,6 +1695,10 @@ "category": "Error", "code": 2518 }, + "An async iterator must have a 'next()' method.": { + "category": "Error", + "code": 2519 + }, "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": { "category": "Error", "code": 2520 @@ -1795,6 +1807,18 @@ "category": "Error", "code": 2546 }, + "The type returned by the 'next()' method of an async iterator must be a promise for a type with a 'value' property.": { + "category": "Error", + "code": 2547 + }, + "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator.": { + "category": "Error", + "code": 2548 + }, + "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator.": { + "category": "Error", + "code": 2549 + }, "JSX element attributes type '{0}' may not be a union type.": { "category": "Error", "code": 2600 @@ -3017,6 +3041,10 @@ "category": "Message", "code": 6148 }, + "Use full down-level iteration for iterables and arrays for 'for-of', spread, and destructuring in ES5/3.": { + "category": "Message", + "code": 6149 + }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", "code": 7005 diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index b60f9ca91fdfc..aa3dc8eac7873 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1450,6 +1450,7 @@ namespace ts { function emitForOfStatement(node: ForOfStatement) { const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos); write(" "); + emitWithSuffix(node.awaitModifier, " "); writeToken(SyntaxKind.OpenParenToken, openParenPos); emitForBinding(node.initializer); write(" of "); @@ -2915,4 +2916,4 @@ namespace ts { Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis, IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets, } -} \ No newline at end of file +} diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index d946933c52ead..48e0950d67f9e 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -286,15 +286,16 @@ namespace ts { return node; } - export function updateMethod(node: MethodDeclaration, decorators: Decorator[], modifiers: Modifier[], name: PropertyName, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { + export function updateMethod(node: MethodDeclaration, decorators: Decorator[], modifiers: Modifier[], asteriskToken: AsteriskToken, name: PropertyName, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { return node.decorators !== decorators || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken || node.name !== name || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body - ? updateNode(createMethod(decorators, modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node) + ? updateNode(createMethod(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) : node; } @@ -554,14 +555,15 @@ namespace ts { return node; } - export function updateFunctionExpression(node: FunctionExpression, modifiers: Modifier[], name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { + export function updateFunctionExpression(node: FunctionExpression, modifiers: Modifier[], asteriskToken: AsteriskToken, name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { return node.name !== name || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body - ? updateNode(createFunctionExpression(modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node) + ? updateNode(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) : node; } @@ -972,19 +974,21 @@ namespace ts { : node; } - export function createForOf(initializer: ForInitializer, expression: Expression, statement: Statement) { + export function createForOf(awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) { const node = createSynthesizedNode(SyntaxKind.ForOfStatement); + node.awaitModifier = awaitModifier; node.initializer = initializer; node.expression = expression; node.statement = statement; return node; } - export function updateForOf(node: ForOfStatement, initializer: ForInitializer, expression: Expression, statement: Statement) { - return node.initializer !== initializer + export function updateForOf(node: ForOfStatement, awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) { + return node.awaitModifier !== awaitModifier + || node.initializer !== initializer || node.expression !== expression || node.statement !== statement - ? updateNode(createForOf(initializer, expression, statement), node) + ? updateNode(createForOf(awaitModifier, initializer, expression, statement), node) : node; } @@ -1107,15 +1111,16 @@ namespace ts { return node; } - export function updateFunctionDeclaration(node: FunctionDeclaration, decorators: Decorator[], modifiers: Modifier[], name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { + export function updateFunctionDeclaration(node: FunctionDeclaration, decorators: Decorator[], modifiers: Modifier[], asteriskToken: AsteriskToken, name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) { return node.decorators !== decorators || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken || node.name !== name || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body - ? updateNode(createFunctionDeclaration(decorators, modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node) + ? updateNode(createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) : node; } @@ -2211,8 +2216,129 @@ namespace ts { return setEmitFlags(createIdentifier(name), EmitFlags.HelperName | EmitFlags.AdviseOnEmitNode); } + const valuesHelper: EmitHelper = { + name: "typescript:values", + scoped: false, + text: ` + var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + }; + ` + }; + + export function createValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(valuesHelper); + return setTextRange( + createCall( + getHelperName("__values"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } + + const readHelper: EmitHelper = { + name: "typescript:read", + scoped: false, + text: ` + var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; + }; + ` + }; + + export function createReadHelper(context: TransformationContext, iteratorRecord: Expression, count: number | undefined, location?: TextRange) { + context.requestEmitHelper(readHelper); + return setTextRange( + createCall( + getHelperName("__read"), + /*typeArguments*/ undefined, + count !== undefined + ? [iteratorRecord, createLiteral(count)] + : [iteratorRecord] + ), + location + ); + } + + const spreadHelper: EmitHelper = { + name: "typescript:spread", + scoped: false, + text: ` + var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; + };` + }; + + export function createSpreadHelper(context: TransformationContext, argumentList: Expression[], location?: TextRange) { + context.requestEmitHelper(readHelper); + context.requestEmitHelper(spreadHelper); + return setTextRange( + createCall( + getHelperName("__spread"), + /*typeArguments*/ undefined, + argumentList + ), + location + ); + } + // Utilities + export function createForOfBindingStatement(node: ForInitializer, boundValue: Expression): Statement { + if (isVariableDeclarationList(node)) { + const firstDeclaration = firstOrUndefined(node.declarations); + const updatedDeclaration = updateVariableDeclaration( + firstDeclaration, + firstDeclaration.name, + /*typeNode*/ undefined, + boundValue + ); + return setTextRange( + createVariableStatement( + /*modifiers*/ undefined, + updateVariableDeclarationList(node, [updatedDeclaration]) + ), + /*location*/ node + ); + } + else { + const updatedExpression = setTextRange(createAssignment(node, boundValue), /*location*/ node); + return setTextRange(createStatement(updatedExpression), /*location*/ node); + } + } + + export function insertLeadingStatement(dest: Statement, source: Statement) { + if (isBlock(dest)) { + return updateBlock(dest, setTextRange(createNodeArray([source, ...dest.statements]), dest.statements)); + } + else { + return createBlock(createNodeArray([dest, source]), /*multiLine*/ true); + } + } + export function restoreEnclosingLabel(node: Statement, outermostLabeledStatement: LabeledStatement, afterRestoreLabelCallback?: (node: LabeledStatement) => void): Statement { if (!outermostLabeledStatement) { return node; @@ -2271,6 +2397,10 @@ namespace ts { ? setTextRange(createIdentifier("_super"), callee) : callee; } + else if (getEmitFlags(callee) & EmitFlags.HelperName) { + thisArg = createVoidZero(); + target = parenthesizeForAccess(callee); + } else { switch (callee.kind) { case SyntaxKind.PropertyAccessExpression: { @@ -2684,6 +2814,16 @@ namespace ts { return statements; } + export function parenthesizeConditionalHead(condition: Expression) { + const conditionalPrecedence = getOperatorPrecedence(SyntaxKind.ConditionalExpression, SyntaxKind.QuestionToken); + const emittedCondition = skipPartiallyEmittedExpressions(condition); + const conditionPrecedence = getExpressionPrecedence(emittedCondition); + if (compareValues(conditionPrecedence, conditionalPrecedence) === Comparison.LessThan) { + return createParen(condition); + } + return condition; + } + /** * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended * order of operations. diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index ebd4208832c14..0d3acd28b1477 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -243,7 +243,8 @@ namespace ts { visitNode(cbNode, (node).expression) || visitNode(cbNode, (node).statement); case SyntaxKind.ForOfStatement: - return visitNode(cbNode, (node).initializer) || + return visitNode(cbNode, (node).awaitModifier) || + visitNode(cbNode, (node).initializer) || visitNode(cbNode, (node).expression) || visitNode(cbNode, (node).statement); case SyntaxKind.ContinueStatement: @@ -4461,6 +4462,7 @@ namespace ts { function parseForOrForInOrForOfStatement(): Statement { const pos = getNodePos(); parseExpected(SyntaxKind.ForKeyword); + const awaitToken = parseOptionalToken(SyntaxKind.AwaitKeyword); parseExpected(SyntaxKind.OpenParenToken); let initializer: VariableDeclarationList | Expression = undefined; @@ -4473,20 +4475,21 @@ namespace ts { } } let forOrForInOrForOfStatement: IterationStatement; - if (parseOptional(SyntaxKind.InKeyword)) { - const forInStatement = createNode(SyntaxKind.ForInStatement, pos); - forInStatement.initializer = initializer; - forInStatement.expression = allowInAnd(parseExpression); - parseExpected(SyntaxKind.CloseParenToken); - forOrForInOrForOfStatement = forInStatement; - } - else if (parseOptional(SyntaxKind.OfKeyword)) { + if (awaitToken ? parseExpected(SyntaxKind.OfKeyword) : parseOptional(SyntaxKind.OfKeyword)) { const forOfStatement = createNode(SyntaxKind.ForOfStatement, pos); + forOfStatement.awaitModifier = awaitToken; forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(SyntaxKind.CloseParenToken); forOrForInOrForOfStatement = forOfStatement; } + else if (parseOptional(SyntaxKind.InKeyword)) { + const forInStatement = createNode(SyntaxKind.ForInStatement, pos); + forInStatement.initializer = initializer; + forInStatement.expression = allowInAnd(parseExpression); + parseExpected(SyntaxKind.CloseParenToken); + forOrForInOrForOfStatement = forInStatement; + } else { const forStatement = createNode(SyntaxKind.ForStatement, pos); forStatement.initializer = initializer; diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts index b4473e6a261e9..b3e6b41d88a10 100644 --- a/src/compiler/transformers/destructuring.ts +++ b/src/compiler/transformers/destructuring.ts @@ -6,6 +6,7 @@ namespace ts { interface FlattenContext { context: TransformationContext; level: FlattenLevel; + downlevelIteration: boolean; hoistTempVariables: boolean; emitExpression: (value: Expression) => void; emitBindingOrAssignment: (target: BindingOrAssignmentElementTarget, value: Expression, location: TextRange, original: Node) => void; @@ -57,6 +58,7 @@ namespace ts { const flattenContext: FlattenContext = { context, level, + downlevelIteration: context.getCompilerOptions().downlevelIteration, hoistTempVariables: true, emitExpression, emitBindingOrAssignment, @@ -146,6 +148,7 @@ namespace ts { const flattenContext: FlattenContext = { context, level, + downlevelIteration: context.getCompilerOptions().downlevelIteration, hoistTempVariables, emitExpression, emitBindingOrAssignment, @@ -312,7 +315,23 @@ namespace ts { function flattenArrayBindingOrAssignmentPattern(flattenContext: FlattenContext, parent: BindingOrAssignmentElement, pattern: ArrayBindingOrAssignmentPattern, value: Expression, location: TextRange) { const elements = getElementsOfBindingOrAssignmentPattern(pattern); const numElements = elements.length; - if (numElements !== 1 && (flattenContext.level < FlattenLevel.ObjectRest || numElements === 0)) { + if (flattenContext.level < FlattenLevel.ObjectRest && flattenContext.downlevelIteration) { + // Read the elements of the iterable into an array + value = ensureIdentifier( + flattenContext, + createReadHelper( + flattenContext.context, + value, + numElements > 0 && getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1]) + ? undefined + : numElements, + location + ), + /*reuseIdentifierExpressions*/ false, + location + ); + } + else if (numElements !== 1 && (flattenContext.level < FlattenLevel.ObjectRest || numElements === 0)) { // For anything other than a single-element destructuring we need to generate a temporary // to ensure value is evaluated exactly once. Additionally, if we have zero elements // we need to emit *something* to ensure that in case a 'var' keyword was already emitted, diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index e0fd435a90dc6..d00f4c73930c8 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -1,5 +1,6 @@ /// /// +/// /*@internal*/ namespace ts { @@ -268,6 +269,7 @@ namespace ts { hoistVariableDeclaration, } = context; + const compilerOptions = context.getCompilerOptions(); const resolver = context.getEmitResolver(); const previousOnSubstituteNode = context.onSubstituteNode; const previousOnEmitNode = context.onEmitNode; @@ -1716,6 +1718,7 @@ namespace ts { return updateFunctionExpression( node, /*modifiers*/ undefined, + node.asteriskToken, name, /*typeParameters*/ undefined, parameters, @@ -1747,6 +1750,7 @@ namespace ts { node, /*decorators*/ undefined, visitNodes(node.modifiers, visitor, isModifier), + node.asteriskToken, name, /*typeParameters*/ undefined, parameters, @@ -1939,6 +1943,9 @@ namespace ts { function visitParenthesizedExpression(node: ParenthesizedExpression, needsDestructuringValue: boolean): ParenthesizedExpression { // If we are here it is most likely because our expression is a destructuring assignment. if (!needsDestructuringValue) { + // By default we always emit the RHS at the end of a flattened destructuring + // expression. If we are in a state where we do not need the destructuring value, + // we pass that information along to the children that care about it. switch (node.expression.kind) { case SyntaxKind.ParenthesizedExpression: return updateParen(node, visitParenthesizedExpression(node.expression, /*needsDestructuringValue*/ false)); @@ -1990,7 +1997,8 @@ namespace ts { else { assignment = createBinary(decl.name, SyntaxKind.EqualsToken, visitNode(decl.initializer, visitor, isExpression)); } - (assignments || (assignments = [])).push(assignment); + + assignments = append(assignments, assignment); } } if (assignments) { @@ -2172,12 +2180,26 @@ namespace ts { if (convertedLoopState && !convertedLoopState.labels) { convertedLoopState.labels = createMap(); } - const statement = unwrapInnermostStatmentOfLabel(node, convertedLoopState && recordLabel); - return isIterationStatement(statement, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatementBody(statement) + const statement = unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel); + return isIterationStatement(statement, /*lookInLabeledStatements*/ false) ? visitIterationStatement(statement, /*outermostLabeledStatement*/ node) : restoreEnclosingLabel(visitNode(statement, visitor, isStatement), node, convertedLoopState && resetLabel); } + function visitIterationStatement(node: IterationStatement, outermostLabeledStatement: LabeledStatement) { + switch (node.kind) { + case SyntaxKind.DoStatement: + case SyntaxKind.WhileStatement: + return visitDoOrWhileStatement(node, outermostLabeledStatement); + case SyntaxKind.ForStatement: + return visitForStatement(node, outermostLabeledStatement); + case SyntaxKind.ForInStatement: + return visitForInStatement(node, outermostLabeledStatement); + case SyntaxKind.ForOfStatement: + return visitForOfStatement(node, outermostLabeledStatement); + } + } + function visitIterationStatementWithFacts(excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts, node: IterationStatement, outermostLabeledStatement: LabeledStatement, convert?: LoopConverter) { const ancestorFacts = enterSubtree(excludeFacts, includeFacts); const updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, convert); @@ -2215,54 +2237,17 @@ namespace ts { HierarchyFacts.ForInOrForOfStatementIncludes, node, outermostLabeledStatement, - convertForOfToFor); + compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray); } - function convertForOfToFor(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement { - // The following ES6 code: - // - // for (let v of expr) { } - // - // should be emitted as - // - // for (var _i = 0, _a = expr; _i < _a.length; _i++) { - // var v = _a[_i]; - // } - // - // where _a and _i are temps emitted to capture the RHS and the counter, - // respectively. - // When the left hand side is an expression instead of a let declaration, - // the "let v" is not emitted. - // When the left hand side is a let/const, the v is renamed if there is - // another v in scope. - // Note that all assignments to the LHS are emitted in the body, including - // all destructuring. - // Note also that because an extra statement is needed to assign to the LHS, - // for-of bodies are always emitted as blocks. - - const expression = visitNode(node.expression, visitor, isExpression); - const initializer = node.initializer; + function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression, convertedLoopBodyStatements: Statement[]) { const statements: Statement[] = []; - - // In the case where the user wrote an identifier as the RHS, like this: - // - // for (let v of arr) { } - // - // we don't want to emit a temporary variable for the RHS, just use it directly. - const counter = createLoopVariable(); - const rhsReference = expression.kind === SyntaxKind.Identifier - ? createUniqueName(unescapeIdentifier((expression).text)) - : createTempVariable(/*recordTempVariable*/ undefined); - const elementAccess = createElementAccess(rhsReference, counter); - - // Initialize LHS - // var v = _a[_i]; - if (isVariableDeclarationList(initializer)) { - if (initializer.flags & NodeFlags.BlockScoped) { + if (isVariableDeclarationList(node.initializer)) { + if (node.initializer.flags & NodeFlags.BlockScoped) { enableSubstitutionsForBlockScopedBindings(); } - const firstOriginalDeclaration = firstOrUndefined(initializer.declarations); + const firstOriginalDeclaration = firstOrUndefined(node.initializer.declarations); if (firstOriginalDeclaration && isBindingPattern(firstOriginalDeclaration.name)) { // This works whether the declaration is a var, let, or const. // It will use rhsIterationValue _a[_i] as the initializer. @@ -2271,12 +2256,11 @@ namespace ts { visitor, context, FlattenLevel.All, - elementAccess + boundValue ); - const declarationList = createVariableDeclarationList(declarations); - setOriginalNode(declarationList, initializer); - setTextRange(declarationList, initializer); + const declarationList = setTextRange(createVariableDeclarationList(declarations), node.initializer); + setOriginalNode(declarationList, node.initializer); // Adjust the source map range for the first declaration to align with the old // emitter. @@ -2304,15 +2288,15 @@ namespace ts { createVariableDeclaration( firstOriginalDeclaration ? firstOriginalDeclaration.name : createTempVariable(/*recordTempVariable*/ undefined), /*type*/ undefined, - createElementAccess(rhsReference, counter) + boundValue ) ]), - moveRangePos(initializer, -1) + moveRangePos(node.initializer, -1) ), - initializer + node.initializer ) ), - moveRangeEnd(initializer, -1) + moveRangeEnd(node.initializer, -1) ) ); } @@ -2320,25 +2304,14 @@ namespace ts { else { // Initializer is an expression. Emit the expression in the body, so that it's // evaluated on every iteration. - const assignment = createAssignment(initializer, elementAccess); + const assignment = createAssignment(node.initializer, boundValue); if (isDestructuringAssignment(assignment)) { - // This is a destructuring pattern, so we flatten the destructuring instead. - statements.push( - createStatement( - flattenDestructuringAssignment( - assignment, - visitor, - context, - FlattenLevel.All - ) - ) - ); + aggregateTransformFlags(assignment); + statements.push(createStatement(visitBinaryExpression(assignment, /*needsDestructuringValue*/ false))); } else { - // Currently there is not way to check that assignment is binary expression of destructing assignment - // so we have to cast never type to binaryExpression - (assignment).end = initializer.end; - statements.push(setTextRange(createStatement(assignment), moveRangeEnd(initializer, -1))); + assignment.end = node.initializer.end; + statements.push(setTextRange(createStatement(visitNode(assignment, visitor, isExpression)), moveRangeEnd(node.initializer, -1))); } } @@ -2359,38 +2332,82 @@ namespace ts { } } - // The old emitter does not emit source maps for the expression - setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression)); - // The old emitter does not emit source maps for the block. // We add the location to preserve comments. - const body = createBlock(setTextRange(createNodeArray(statements), /*location*/ statementsLocation)); - setTextRange(body, bodyLocation); - setEmitFlags(body, EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps); - - const forStatement = createFor( - setEmitFlags( - setTextRange( - createVariableDeclarationList([ - setTextRange(createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0)), moveRangePos(node.expression, -1)), - setTextRange(createVariableDeclaration(rhsReference, /*type*/ undefined, expression), node.expression) - ]), - node.expression - ), - EmitFlags.NoHoisting - ), + return setEmitFlags( setTextRange( - createLessThan( - counter, - createPropertyAccess(rhsReference, "length") + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true ), - node.expression + bodyLocation, ), - setTextRange( - createPostfixIncrement(counter), - node.expression + EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps + ); + } + + function convertForOfStatementForArray(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement { + // The following ES6 code: + // + // for (let v of expr) { } + // + // should be emitted as + // + // for (var _i = 0, _a = expr; _i < _a.length; _i++) { + // var v = _a[_i]; + // } + // + // where _a and _i are temps emitted to capture the RHS and the counter, + // respectively. + // When the left hand side is an expression instead of a let declaration, + // the "let v" is not emitted. + // When the left hand side is a let/const, the v is renamed if there is + // another v in scope. + // Note that all assignments to the LHS are emitted in the body, including + // all destructuring. + // Note also that because an extra statement is needed to assign to the LHS, + // for-of bodies are always emitted as blocks. + + const expression = visitNode(node.expression, visitor, isExpression); + + // In the case where the user wrote an identifier as the RHS, like this: + // + // for (let v of arr) { } + // + // we don't want to emit a temporary variable for the RHS, just use it directly. + const counter = createLoopVariable(); + const rhsReference = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined); + + // The old emitter does not emit source maps for the expression + setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression)); + + const forStatement = setTextRange( + createFor( + /*initializer*/ setEmitFlags( + setTextRange( + createVariableDeclarationList([ + setTextRange(createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0)), moveRangePos(node.expression, -1)), + setTextRange(createVariableDeclaration(rhsReference, /*type*/ undefined, expression), node.expression) + ]), + node.expression + ), + EmitFlags.NoHoisting + ), + /*condition*/ setTextRange( + createLessThan( + counter, + createPropertyAccess(rhsReference, "length") + ), + node.expression + ), + /*incrementor*/ setTextRange(createPostfixIncrement(counter), node.expression), + /*statement*/ convertForOfStatementHead( + node, + createElementAccess(rhsReference, counter), + convertedLoopBodyStatements + ) ), - body + /*location*/ node ); // Disable trailing source maps for the OpenParenToken to align source map emit with the old emitter. @@ -2399,18 +2416,110 @@ namespace ts { return restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel); } - function visitIterationStatement(node: IterationStatement, outermostLabeledStatement: LabeledStatement) { - switch (node.kind) { - case SyntaxKind.DoStatement: - case SyntaxKind.WhileStatement: - return visitDoOrWhileStatement(node, outermostLabeledStatement); - case SyntaxKind.ForStatement: - return visitForStatement(node, outermostLabeledStatement); - case SyntaxKind.ForInStatement: - return visitForInStatement(node, outermostLabeledStatement); - case SyntaxKind.ForOfStatement: - return visitForOfStatement(node, outermostLabeledStatement); - } + function convertForOfStatementForIterable(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement { + 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 values = createValuesHelper(context, expression, node.expression); + const next = createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []); + + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + + const forStatement = setEmitFlags( + setTextRange( + createFor( + /*initializer*/ setEmitFlags( + setTextRange( + createVariableDeclarationList([ + setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression), + createVariableDeclaration(result, /*type*/ undefined, next) + ]), + node.expression + ), + EmitFlags.NoHoisting + ), + /*condition*/ createLogicalNot(createPropertyAccess(result, "done")), + /*incrementor*/ createAssignment(result, next), + /*statement*/ convertForOfStatementHead( + node, + createPropertyAccess(result, "value"), + convertedLoopBodyStatements + ) + ), + /*location*/ node + ), + EmitFlags.NoTokenTrailingSourceMaps + ); + + return createTry( + createBlock([ + restoreEnclosingLabel( + forStatement, + outermostLabeledStatement, + convertedLoopState && resetLabel + ) + ]), + createCatchClause(createVariableDeclaration(catchVariable), + setEmitFlags( + createBlock([ + createStatement( + createAssignment( + errorRecord, + createObjectLiteral([ + createPropertyAssignment("error", catchVariable) + ]) + ) + ) + ]), + EmitFlags.SingleLine + ) + ), + createBlock([ + createTry( + /*tryBlock*/ createBlock([ + setEmitFlags( + createIf( + createLogicalAnd( + createLogicalAnd( + result, + createLogicalNot( + createPropertyAccess(result, "done") + ) + ), + createAssignment( + returnMethod, + createPropertyAccess(iterator, "return") + ) + ), + createStatement( + createFunctionCall(returnMethod, iterator, []) + ) + ), + EmitFlags.SingleLine + ), + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ setEmitFlags( + createBlock([ + setEmitFlags( + createIf( + errorRecord, + createThrow( + createPropertyAccess(errorRecord, "error") + ) + ), + EmitFlags.SingleLine + ) + ]), + EmitFlags.SingleLine + ) + ) + ]) + ); } /** @@ -2712,6 +2821,7 @@ namespace ts { } const convertedLoopBodyStatements = generateCallToConvertedLoop(functionName, loopParameters, currentState, isAsyncBlockContainingAwait); + let loop: Statement; if (convert) { loop = convert(node, outermostLabeledStatement, convertedLoopBodyStatements); @@ -3239,15 +3349,30 @@ namespace ts { ) ); - if (segments.length === 1) { - const firstElement = elements[0]; - return needsUniqueCopy && isSpreadExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression - ? createArraySlice(segments[0]) - : segments[0]; + if (compilerOptions.downlevelIteration) { + if (segments.length === 1) { + const firstSegment = segments[0]; + if (isCallExpression(firstSegment) + && isIdentifier(firstSegment.expression) + && (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName) + && firstSegment.expression.text === "___spread") { + return segments[0]; + } + } + + return createSpreadHelper(context, segments); } + else { + if (segments.length === 1) { + const firstElement = elements[0]; + return needsUniqueCopy && isSpreadExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression + ? createArraySlice(segments[0]) + : segments[0]; + } - // Rewrite using the pattern .concat(, , ...) - return createArrayConcat(segments.shift(), segments); + // Rewrite using the pattern .concat(, , ...) + return createArrayConcat(segments.shift(), segments); + } } function partitionSpread(node: Expression) { diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts index b437298656c5d..31aae5055a002 100644 --- a/src/compiler/transformers/es2017.ts +++ b/src/compiler/transformers/es2017.ts @@ -14,7 +14,7 @@ namespace ts { const { startLexicalEnvironment, resumeLexicalEnvironment, - endLexicalEnvironment, + endLexicalEnvironment } = context; const resolver = context.getEmitResolver(); @@ -34,7 +34,7 @@ namespace ts { * This keeps track of containers where `super` is valid, for use with * just-in-time substitution for `super` expressions inside of async methods. */ - let currentSuperContainer: SuperContainer; + let enclosingSuperContainerFlags: NodeCheckFlags = 0; // Save the previous transformation hooks. const previousOnEmitNode = context.onEmitNode; @@ -71,23 +71,18 @@ namespace ts { return undefined; case SyntaxKind.AwaitExpression: - // ES2017 'await' expressions must be transformed for targets < ES2017. return visitAwaitExpression(node); case SyntaxKind.MethodDeclaration: - // ES2017 method declarations may be 'async' return visitMethodDeclaration(node); case SyntaxKind.FunctionDeclaration: - // ES2017 function declarations may be 'async' return visitFunctionDeclaration(node); case SyntaxKind.FunctionExpression: - // ES2017 function expressions may be 'async' return visitFunctionExpression(node); case SyntaxKind.ArrowFunction: - // ES2017 arrow functions may be 'async' return visitArrowFunction(node); default: @@ -128,11 +123,12 @@ namespace ts { node, /*decorators*/ undefined, visitNodes(node.modifiers, visitor, isModifier), + node.asteriskToken, node.name, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - isAsyncFunctionLike(node) + getFunctionFlags(node) & FunctionFlags.Async ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context) ); @@ -151,11 +147,12 @@ namespace ts { node, /*decorators*/ undefined, visitNodes(node.modifiers, visitor, isModifier), + node.asteriskToken, node.name, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - isAsyncFunctionLike(node) + getFunctionFlags(node) & FunctionFlags.Async ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context) ); @@ -170,17 +167,15 @@ namespace ts { * @param node The node to visit. */ function visitFunctionExpression(node: FunctionExpression): Expression { - if (nodeIsMissing(node.body)) { - return createOmittedExpression(); - } return updateFunctionExpression( node, - /*modifiers*/ undefined, + visitNodes(node.modifiers, visitor, isModifier), + node.asteriskToken, node.name, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - isAsyncFunctionLike(node) + getFunctionFlags(node) & FunctionFlags.Async ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context) ); @@ -201,7 +196,7 @@ namespace ts { /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - isAsyncFunctionLike(node) + getFunctionFlags(node) & FunctionFlags.Async ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context) ); @@ -320,6 +315,44 @@ namespace ts { } } + /** + * Hook for node emit. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emit A callback used to emit the node in the printer. + */ + function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void { + // If we need to support substitutions for `super` in an async method, + // we should track it here. + if (enabledSubstitutions & ES2017SubstitutionFlags.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; + } + } + previousOnEmitNode(hint, node, emitCallback); + } + + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @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: @@ -327,62 +360,45 @@ namespace ts { case SyntaxKind.ElementAccessExpression: return substituteElementAccessExpression(node); case SyntaxKind.CallExpression: - if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper) { - return substituteCallExpression(node); - } - break; + return substituteCallExpression(node); } - return node; } function substitutePropertyAccessExpression(node: PropertyAccessExpression) { - if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) { - const flags = getSuperContainerAsyncMethodFlags(); - if (flags) { - return createSuperAccessInAsyncMethod( - createLiteral(node.name.text), - flags, - node - ); - } + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return createSuperAccessInAsyncMethod( + createLiteral(node.name.text), + node + ); } - return node; } function substituteElementAccessExpression(node: ElementAccessExpression) { - if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) { - const flags = getSuperContainerAsyncMethodFlags(); - if (flags) { - return createSuperAccessInAsyncMethod( - node.argumentExpression, - flags, - node - ); - } + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return createSuperAccessInAsyncMethod( + node.argumentExpression, + node + ); } - return node; } function substituteCallExpression(node: CallExpression): Expression { const expression = node.expression; if (isSuperProperty(expression)) { - const flags = getSuperContainerAsyncMethodFlags(); - if (flags) { - const argumentExpression = isPropertyAccessExpression(expression) - ? substitutePropertyAccessExpression(expression) - : substituteElementAccessExpression(expression); - return createCall( - createPropertyAccess(argumentExpression, "call"), - /*typeArguments*/ undefined, - [ - createThis(), - ...node.arguments - ] - ); - } + const argumentExpression = isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return createCall( + createPropertyAccess(argumentExpression, "call"), + /*typeArguments*/ undefined, + [ + createThis(), + ...node.arguments + ] + ); } return node; } @@ -396,44 +412,8 @@ namespace ts { || kind === SyntaxKind.SetAccessor; } - /** - * Hook for node emit. - * - * @param hint A hint as to the intended usage of the node. - * @param node The node to emit. - * @param emit A callback used to emit the node in the printer. - */ - function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void { - // If we need to support substitutions for `super` in an async method, - // we should track it here. - if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) { - const savedCurrentSuperContainer = currentSuperContainer; - currentSuperContainer = node; - previousOnEmitNode(hint, node, emitCallback); - currentSuperContainer = savedCurrentSuperContainer; - } - else { - previousOnEmitNode(hint, node, emitCallback); - } - } - - /** - * Hooks node substitutions. - * - * @param hint A hint as to the intended usage of the node. - * @param node The node to substitute. - */ - function onSubstituteNode(hint: EmitHint, node: Node) { - node = previousOnSubstituteNode(hint, node); - if (hint === EmitHint.Expression) { - return substituteExpression(node); - } - - return node; - } - - function createSuperAccessInAsyncMethod(argumentExpression: Expression, flags: NodeCheckFlags, location: TextRange): LeftHandSideExpression { - if (flags & NodeCheckFlags.AsyncMethodWithSuperBinding) { + function createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { + if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { return setTextRange( createPropertyAccess( createCall( @@ -457,15 +437,26 @@ namespace ts { ); } } - - function getSuperContainerAsyncMethodFlags() { - return currentSuperContainer !== undefined - && resolver.getNodeCheckFlags(currentSuperContainer) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding); - } } + const awaiterHelper: EmitHelper = { + name: "typescript:awaiter", + scoped: false, + priority: 5, + text: ` + var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + };` + }; + function createAwaiterHelper(context: TransformationContext, hasLexicalArguments: boolean, promiseConstructor: EntityName | Expression, body: Block) { context.requestEmitHelper(awaiterHelper); + const generatorFunc = createFunctionExpression( /*modifiers*/ undefined, createToken(SyntaxKind.AsteriskToken), @@ -491,35 +482,22 @@ namespace ts { ); } - const awaiterHelper: EmitHelper = { - name: "typescript:awaiter", - scoped: false, - priority: 5, - text: ` - var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); - };` - }; - - const asyncSuperHelper: EmitHelper = { + export const asyncSuperHelper: EmitHelper = { name: "typescript:async-super", scoped: true, text: ` - const _super = name => super[name];` + const _super = name => super[name]; + ` }; - const advancedAsyncSuperHelper: EmitHelper = { + export const advancedAsyncSuperHelper: EmitHelper = { name: "typescript:advanced-async-super", scoped: true, text: ` const _super = (function (geti, seti) { const cache = Object.create(null); return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } }); - })(name => super[name], (name, value) => super[name] = value);` + })(name => super[name], (name, value) => super[name] = value); + ` }; } diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index f058e627df701..e114873c056e8 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -1,13 +1,35 @@ /// /// +/// /*@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 + 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; + return transformSourceFile; function transformSourceFile(node: SourceFile) { @@ -28,12 +50,25 @@ namespace ts { 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.LabeledStatement: + return visitLabeledStatement(node as LabeledStatement); case SyntaxKind.ObjectLiteralExpression: return visitObjectLiteralExpression(node as ObjectLiteralExpression); case SyntaxKind.BinaryExpression: @@ -41,7 +76,7 @@ namespace ts { case SyntaxKind.VariableDeclaration: return visitVariableDeclaration(node as VariableDeclaration); case SyntaxKind.ForOfStatement: - return visitForOfStatement(node as ForOfStatement); + return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined); case SyntaxKind.ForStatement: return visitForStatement(node as ForStatement); case SyntaxKind.VoidExpression: @@ -71,6 +106,51 @@ namespace ts { } } + function visitAwaitExpression(node: AwaitExpression) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + const expression = visitNode(node.expression, visitor, isExpression); + return setOriginalNode( + setTextRange( + createYield( + /*asteriskToken*/ undefined, + createArrayLiteral([createLiteral("await"), expression]) + ), + /*location*/ node + ), + node + ); + } + return visitEachChild(node, visitor, context); + } + + function visitYieldExpression(node: YieldExpression) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + const expression = visitNode(node.expression, visitor, isExpression); + return updateYield( + node, + node.asteriskToken + ? createAsyncDelegatorHelper(context, expression, expression) + : createArrayLiteral( + expression + ? [createLiteral("yield"), expression] + : [createLiteral("yield")] + ) + ); + } + return visitEachChild(node, visitor, context); + } + + function visitLabeledStatement(node: LabeledStatement) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + const statement = unwrapInnermostStatementOfLabel(node); + if (statement.kind === SyntaxKind.ForOfStatement && (statement).awaitModifier) { + return visitForOfStatement(statement, node); + } + return restoreEnclosingLabel(visitEachChild(node, visitor, context), node); + } + return visitEachChild(node, visitor, context); + } + function chunkObjectLiteralElements(elements: ObjectLiteralElement[]): Expression[] { let chunkObject: (ShorthandPropertyAssignment | PropertyAssignment)[]; const objects: Expression[] = []; @@ -189,67 +269,195 @@ namespace ts { * * @param node A ForOfStatement. */ - function visitForOfStatement(node: ForOfStatement): VisitResult { - let leadingStatements: Statement[]; - let temp: Identifier; - const initializer = skipParentheses(node.initializer); - if (initializer.transformFlags & TransformFlags.ContainsObjectRest) { - if (isVariableDeclarationList(initializer)) { - temp = createTempVariable(/*recordTempVariable*/ undefined); - const firstDeclaration = firstOrUndefined(initializer.declarations); - const declarations = flattenDestructuringBinding( - firstDeclaration, - visitor, - context, - FlattenLevel.ObjectRest, - temp, - /*doNotRecordTempVariablesInLine*/ false, - /*skipInitializer*/ true, - ); - if (some(declarations)) { - const statement = createVariableStatement( - /*modifiers*/ undefined, - updateVariableDeclarationList(initializer, declarations), - ); - setTextRange(statement, initializer); - leadingStatements = append(leadingStatements, statement); - } - } - else if (isAssignmentPattern(initializer)) { - temp = createTempVariable(/*recordTempVariable*/ undefined); - const expression = flattenDestructuringAssignment( - aggregateTransformFlags( - setTextRange( - createAssignment(initializer, temp), - node.initializer - ) - ), - visitor, - context, - FlattenLevel.ObjectRest - ); - leadingStatements = append(leadingStatements, setTextRange(createStatement(expression), node.initializer)); - } + function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement): VisitResult { + if (node.initializer.transformFlags & TransformFlags.ContainsObjectRest) { + node = transformForOfStatementWithObjectRest(node); } - if (temp) { - const expression = visitNode(node.expression, visitor, isExpression); - const statement = visitNode(node.statement, visitor, isStatement); - const block = isBlock(statement) - ? updateBlock(statement, setTextRange(createNodeArray(concatenate(leadingStatements, statement.statements)), statement.statements)) - : setTextRange(createBlock(append(leadingStatements, statement), /*multiLine*/ true), statement); + 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; + let statementsLocation: TextRange; + 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; + } return updateForOf( node, + node.awaitModifier, setTextRange( - createVariableDeclarationList([ - setTextRange(createVariableDeclaration(temp), node.initializer) - ], NodeFlags.Let), + createVariableDeclarationList( + [ + setTextRange(createVariableDeclaration(temp), node.initializer) + ], + NodeFlags.Let + ), node.initializer ), - expression, - block + node.expression, + setTextRange( + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true + ), + bodyLocation + ) ); } - return visitEachChild(node, visitor, context); + return node; + } + + function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) { + const binding = createForOfBindingStatement(node.initializer, boundValue); + + let bodyLocation: TextRange; + let statementsLocation: TextRange; + 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 transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement) { + 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 values = createAsyncValuesHelper(context, expression, /*location*/ node.expression); + const next = createYield( + /*asteriskToken*/ undefined, + createArrayLiteral([ + createLiteral("await"), + createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []) + ]) + ); + + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + + const forStatement = setEmitFlags( + setTextRange( + createFor( + /*initializer*/ setEmitFlags( + setTextRange( + createVariableDeclarationList([ + setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression), + createVariableDeclaration(result, /*type*/ undefined, next) + ]), + node.expression + ), + EmitFlags.NoHoisting + ), + /*condition*/ createLogicalNot(createPropertyAccess(result, "done")), + /*incrementor*/ createAssignment(result, next), + /*statement*/ convertForOfStatementHead(node, createPropertyAccess(result, "value")) + ), + /*location*/ node + ), + EmitFlags.NoTokenTrailingSourceMaps + ); + + return createTry( + createBlock([ + restoreEnclosingLabel( + forStatement, + outermostLabeledStatement + ) + ]), + createCatchClause( + createVariableDeclaration(catchVariable), + setEmitFlags( + createBlock([ + createStatement( + createAssignment( + errorRecord, + createObjectLiteral([ + createPropertyAssignment("error", catchVariable) + ]) + ) + ) + ]), + EmitFlags.SingleLine + ) + ), + createBlock([ + createTry( + /*tryBlock*/ createBlock([ + setEmitFlags( + createIf( + createLogicalAnd( + createLogicalAnd( + result, + createLogicalNot( + createPropertyAccess(result, "done") + ) + ), + createAssignment( + returnMethod, + createPropertyAccess(iterator, "return") + ) + ), + createStatement( + createYield( + /*asteriskToken*/ undefined, + createArrayLiteral([ + createLiteral("await"), + createFunctionCall(returnMethod, iterator, []) + ]) + ) + ) + ), + EmitFlags.SingleLine + ) + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ setEmitFlags( + createBlock([ + setEmitFlags( + createIf( + errorRecord, + createThrow( + createPropertyAccess(errorRecord, "error") + ) + ), + EmitFlags.SingleLine + ) + ]), + EmitFlags.SingleLine + ) + ) + ]) + ); } function visitParameter(node: ParameterDeclaration): ParameterDeclaration { @@ -270,17 +478,23 @@ namespace ts { } function visitConstructorDeclaration(node: ConstructorDeclaration) { - return updateConstructor( + 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) { - return updateGetAccessor( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateGetAccessor( node, /*decorators*/ undefined, node.modifiers, @@ -289,10 +503,14 @@ namespace ts { /*type*/ undefined, transformFunctionBody(node) ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; } function visitSetAccessorDeclaration(node: SetAccessorDeclaration) { - return updateSetAccessor( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateSetAccessor( node, /*decorators*/ undefined, node.modifiers, @@ -300,36 +518,62 @@ namespace ts { visitParameterList(node.parameters, visitor, context), transformFunctionBody(node) ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; } function visitMethodDeclaration(node: MethodDeclaration) { - return updateMethod( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateMethod( node, /*decorators*/ undefined, - node.modifiers, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, visitNode(node.name, visitor, isPropertyName), /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - transformFunctionBody(node) + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; } function visitFunctionDeclaration(node: FunctionDeclaration) { - return updateFunctionDeclaration( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionDeclaration( node, /*decorators*/ undefined, - node.modifiers, + 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, - transformFunctionBody(node) + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; } function visitArrowFunction(node: ArrowFunction) { - return updateArrowFunction( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateArrowFunction( node, node.modifiers, /*typeParameters*/ undefined, @@ -337,25 +581,92 @@ namespace ts { /*type*/ undefined, transformFunctionBody(node) ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; } function visitFunctionExpression(node: FunctionExpression) { - return updateFunctionExpression( + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionExpression( node, - node.modifiers, + 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, - transformFunctionBody(node) + 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 = addPrologueDirectives(statements, node.body.statements, /*ensureUseStrict*/ false, visitor); + appendObjectRestAssignmentsIfNeeded(statements, node); + + statements.push( + 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) + ) + ) + ) + ) + ); + + addRange(statements, endLexicalEnvironment()); + const block = updateBlock(node.body, statements); + + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + if (languageVersion >= ScriptTarget.ES2015) { + if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) { + enableSubstitutionForAsyncMethodsWithSuper(); + addEmitHelper(block, advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) { + enableSubstitutionForAsyncMethodsWithSuper(); + addEmitHelper(block, asyncSuperHelper); + } + } + return block; } function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody; function transformFunctionBody(node: ArrowFunction): ConciseBody; function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { resumeLexicalEnvironment(); - let leadingStatements: Statement[]; + const leadingStatements = appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node); + const body = visitNode(node.body, visitor, isConciseBody); + const trailingStatements = endLexicalEnvironment(); + if (some(leadingStatements) || some(trailingStatements)) { + const block = convertToFunctionBody(body, /*multiLine*/ true); + return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements)); + } + return body; + } + + function appendObjectRestAssignmentsIfNeeded(statements: Statement[], node: FunctionLikeDeclaration): Statement[] { for (const parameter of node.parameters) { if (parameter.transformFlags & TransformFlags.ContainsObjectRest) { const temp = getGeneratedNameForNode(parameter); @@ -376,17 +687,153 @@ namespace ts { ) ); setEmitFlags(statement, EmitFlags.CustomPrologue); - leadingStatements = append(leadingStatements, statement); + statements = append(statements, statement); } } } - const body = visitNode(node.body, visitor, isConciseBody); - const trailingStatements = endLexicalEnvironment(); - if (some(leadingStatements) || some(trailingStatements)) { - const block = convertToFunctionBody(body, /*multiLine*/ true); - return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements)); + 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); + } + } + + /** + * 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; + } + } + + 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 createSuperAccessInAsyncMethod( + createLiteral(node.name.text), + node + ); + } + return node; + } + + function substituteElementAccessExpression(node: ElementAccessExpression) { + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return createSuperAccessInAsyncMethod( + 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 createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { + if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { + return setTextRange( + createPropertyAccess( + createCall( + createIdentifier("_super"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + "value" + ), + location + ); + } + else { + return setTextRange( + createCall( + createIdentifier("_super"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + location + ); } - return body; } } @@ -418,4 +865,87 @@ namespace ts { attributesSegments ); } + + const asyncGeneratorHelper: EmitHelper = { + name: "typescript:asyncGenerator", + scoped: false, + text: ` + var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } + }; + ` + }; + + function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) { + context.requestEmitHelper(asyncGeneratorHelper); + + // Mark this node as originally an async function + (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= EmitFlags.AsyncFunctionBody; + + return createCall( + getHelperName("__asyncGenerator"), + /*typeArguments*/ undefined, + [ + createThis(), + createIdentifier("arguments"), + generatorFunc + ] + ); + } + + const asyncDelegator: EmitHelper = { + name: "typescript:asyncDelegator", + scoped: false, + text: ` + var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } + }; + ` + }; + + function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(asyncDelegator); + return setTextRange( + createCall( + getHelperName("__asyncDelegator"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } + + const asyncValues: EmitHelper = { + name: "typescript:asyncValues", + scoped: false, + text: ` + var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); + }; + ` + }; + + 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 cabd5d2a96d01..4ecb2d5f51b53 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -232,7 +232,7 @@ namespace ts { resumeLexicalEnvironment, endLexicalEnvironment, hoistFunctionDeclaration, - hoistVariableDeclaration, + hoistVariableDeclaration } = context; const compilerOptions = context.getCompilerOptions(); @@ -448,7 +448,7 @@ namespace ts { */ function visitFunctionDeclaration(node: FunctionDeclaration): Statement { // Currently, we only support generators that were originally async functions. - if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) { + if (node.asteriskToken) { node = setOriginalNode( setTextRange( createFunctionDeclaration( @@ -498,7 +498,7 @@ namespace ts { */ function visitFunctionExpression(node: FunctionExpression): Expression { // Currently, we only support generators that were originally async functions. - if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) { + if (node.asteriskToken) { node = setOriginalNode( setTextRange( createFunctionExpression( @@ -936,11 +936,10 @@ namespace ts { // .mark resumeLabel // x = %sent%; - // NOTE: we are explicitly not handling YieldStar at this time. const resumeLabel = defineLabel(); const expression = visitNode(node.expression, visitor, isExpression); if (node.asteriskToken) { - emitYieldStar(expression, /*location*/ node); + emitYieldStar(createValuesHelper(context, expression, /*location*/ node), /*location*/ node); } else { emitYield(expression, /*location*/ node); @@ -978,9 +977,10 @@ namespace ts { // ar = _a.concat([%sent%, 2]); const numInitialElements = countInitialNodesWithoutYield(elements); - const temp = declareLocal(); - let hasAssignedTemp = false; + + let temp: Identifier; if (numInitialElements > 0) { + temp = declareLocal(); const initialElements = visitNodes(elements, visitor, isExpression, 0, numInitialElements); emitAssignment(temp, createArrayLiteral( @@ -990,11 +990,10 @@ namespace ts { ) ); leadingElement = undefined; - hasAssignedTemp = true; } const expressions = reduceLeft(elements, reduceElement, [], numInitialElements); - return hasAssignedTemp + return temp ? createArrayConcat(temp, [createArrayLiteral(expressions, multiLine)]) : setTextRange( createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine), @@ -1003,6 +1002,11 @@ namespace ts { function reduceElement(expressions: Expression[], element: Expression) { if (containsYield(element) && expressions.length > 0) { + const hasAssignedTemp = temp !== undefined; + if (!temp) { + temp = declareLocal(); + } + emitAssignment( temp, hasAssignedTemp @@ -1015,7 +1019,6 @@ namespace ts { multiLine ) ); - hasAssignedTemp = true; leadingElement = undefined; expressions = []; } @@ -1960,7 +1963,7 @@ namespace ts { function cacheExpression(node: Expression): Identifier { let temp: Identifier; - if (isGeneratedIdentifier(node)) { + if (isGeneratedIdentifier(node) || getEmitFlags(node) & EmitFlags.HelperName) { return node; } @@ -3229,8 +3232,8 @@ namespace ts { priority: 6, text: ` var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/src/compiler/transformers/jsx.ts b/src/compiler/transformers/jsx.ts index fb84736ffda73..e9455490a5de5 100644 --- a/src/compiler/transformers/jsx.ts +++ b/src/compiler/transformers/jsx.ts @@ -6,7 +6,6 @@ namespace ts { export function transformJsx(context: TransformationContext) { const compilerOptions = context.getCompilerOptions(); - let currentSourceFile: SourceFile; return transformSourceFile; @@ -20,12 +19,8 @@ namespace ts { return node; } - currentSourceFile = node; - const visited = visitEachChild(node, visitor, context); addEmitHelpers(visited, context.readEmitHelpers()); - - currentSourceFile = undefined; return visited; } diff --git a/src/compiler/transformers/module/es2015.ts b/src/compiler/transformers/module/es2015.ts index cc197073c32e5..7028e23596154 100644 --- a/src/compiler/transformers/module/es2015.ts +++ b/src/compiler/transformers/module/es2015.ts @@ -101,6 +101,7 @@ namespace ts { if (isIdentifier(node) && hint === EmitHint.Expression) { return substituteExpressionIdentifier(node); } + return node; } diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index bf963bdc0e5c9..421bb0d503050 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -1,5 +1,6 @@ /// /// +/// /*@internal*/ namespace ts { @@ -90,11 +91,13 @@ namespace ts { append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement, /*optional*/ true)); addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset)); - addRange(statements, endLexicalEnvironment()); addExportEqualsIfNeeded(statements, /*emitAsReturn*/ false); + addRange(statements, endLexicalEnvironment()); const updated = updateSourceFileNode(node, setTextRange(createNodeArray(statements), node.statements)); if (currentModuleInfo.hasExportStarsToExportValues) { + // If we have any `export * from ...` declarations + // we need to inform the emitter to add the __export helper. addEmitHelper(updated, exportStarHelper); } return updated; @@ -383,13 +386,13 @@ namespace ts { append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement, /*optional*/ true)); addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset)); + // Append the 'export =' statement if provided. + addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true); + // End the lexical environment for the module body // and merge any new lexical declarations. addRange(statements, endLexicalEnvironment()); - // Append the 'export =' statement if provided. - addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true); - const body = createBlock(statements, /*multiLine*/ true); if (currentModuleInfo.hasExportStarsToExportValues) { // If we have any `export * from ...` declarations @@ -1334,6 +1337,7 @@ namespace ts { if (externalHelpersModuleName) { return createPropertyAccess(externalHelpersModuleName, node); } + return node; } diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index b29992015041f..aece70ac62535 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -1,5 +1,6 @@ /// /// +/// /*@internal*/ namespace ts { @@ -136,7 +137,6 @@ namespace ts { contextObject = undefined; hoistedStatements = undefined; enclosingBlockScopedContainer = undefined; - return aggregateTransformFlags(updated); } @@ -669,6 +669,7 @@ namespace ts { node, node.decorators, visitNodes(node.modifiers, modifierVisitor, isModifier), + node.asteriskToken, getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), /*typeParameters*/ undefined, visitNodes(node.parameters, destructuringVisitor, isParameterDeclaration), @@ -1258,6 +1259,7 @@ namespace ts { node = updateForOf( node, + node.awaitModifier, visitForInitializer(node.initializer), visitNode(node.expression, destructuringVisitor, isExpression), visitNode(node.statement, nestedElementVisitor, isStatement, /*optional*/ false, liftToBlock) @@ -1492,7 +1494,7 @@ namespace ts { * @param node The destructuring target. */ function hasExportedReferenceInDestructuringTarget(node: Expression | ObjectLiteralElementLike): boolean { - if (isAssignmentExpression(node)) { + if (isAssignmentExpression(node, /*excludeCompoundAssignment*/ true)) { return hasExportedReferenceInDestructuringTarget(node.left); } else if (isSpreadExpression(node)) { @@ -1625,6 +1627,7 @@ namespace ts { if (externalHelpersModuleName) { return createPropertyAccess(externalHelpersModuleName, node); } + return node; } diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 4ef3bd5c067d9..ce5d776bff9a3 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -872,7 +872,7 @@ namespace ts { * @param hasExtendsClause A value indicating whether the class has an extends clause. */ function transformConstructorBody(node: ClassExpression | ClassDeclaration, constructor: ConstructorDeclaration, hasExtendsClause: boolean) { - const statements: Statement[] = []; + let statements: Statement[] = []; let indexOfFirstStatement = 0; resumeLexicalEnvironment(); @@ -930,7 +930,7 @@ namespace ts { } // End the lexical environment. - addRange(statements, endLexicalEnvironment()); + statements = mergeLexicalEnvironment(statements, endLexicalEnvironment()); return setTextRange( createBlock( setTextRange( @@ -1651,7 +1651,7 @@ namespace ts { if (isFunctionLike(node) && node.type) { return serializeTypeNode(node.type); } - else if (isAsyncFunctionLike(node)) { + else if (isAsyncFunction(node)) { return createIdentifier("Promise"); } @@ -2019,7 +2019,13 @@ namespace ts { return undefined; } - return visitEachChild(node, visitor, context); + return updateConstructor( + node, + visitNodes(node.decorators, visitor, isDecorator), + visitNodes(node.modifiers, visitor, isModifier), + visitParameterList(node.parameters, visitor, context), + visitFunctionBody(node.body, visitor, context) + ); } /** @@ -2040,6 +2046,7 @@ namespace ts { node, /*decorators*/ undefined, visitNodes(node.modifiers, modifierVisitor, isModifier), + node.asteriskToken, visitPropertyNameOfClassElement(node), /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), @@ -2144,6 +2151,7 @@ namespace ts { node, /*decorators*/ undefined, visitNodes(node.modifiers, modifierVisitor, isModifier), + node.asteriskToken, node.name, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), @@ -2167,17 +2175,18 @@ namespace ts { * @param node The function expression node. */ function visitFunctionExpression(node: FunctionExpression): Expression { - if (nodeIsMissing(node.body)) { + if (!shouldEmitFunctionLikeDeclaration(node)) { return createOmittedExpression(); } const updated = updateFunctionExpression( node, visitNodes(node.modifiers, modifierVisitor, isModifier), + node.asteriskToken, node.name, /*typeParameters*/ undefined, visitParameterList(node.parameters, visitor, context), /*type*/ undefined, - visitFunctionBody(node.body, visitor, context) + visitFunctionBody(node.body, visitor, context) || createBlock([]) ); return updated; } @@ -3187,6 +3196,11 @@ namespace ts { */ function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void { const savedApplicableSubstitutions = applicableSubstitutions; + const savedCurrentSourceFile = currentSourceFile; + + if (isSourceFile(node)) { + currentSourceFile = node; + } if (enabledSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && isTransformedModuleDeclaration(node)) { applicableSubstitutions |= TypeScriptSubstitutionFlags.NamespaceExports; @@ -3199,6 +3213,7 @@ namespace ts { previousOnEmitNode(hint, node, emitCallback); applicableSubstitutions = savedApplicableSubstitutions; + currentSourceFile = savedCurrentSourceFile; } /** @@ -3340,38 +3355,38 @@ namespace ts { } } - const paramHelper: EmitHelper = { - name: "typescript:param", - scoped: false, - priority: 4, - text: ` - var __param = (this && this.__param) || function (paramIndex, decorator) { - return function (target, key) { decorator(target, key, paramIndex); } - };` - }; + function createDecorateHelper(context: TransformationContext, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) { + const argumentsArray: Expression[] = []; + argumentsArray.push(createArrayLiteral(decoratorExpressions, /*multiLine*/ true)); + argumentsArray.push(target); + if (memberName) { + argumentsArray.push(memberName); + if (descriptor) { + argumentsArray.push(descriptor); + } + } - function createParamHelper(context: TransformationContext, expression: Expression, parameterOffset: number, location?: TextRange) { - context.requestEmitHelper(paramHelper); + context.requestEmitHelper(decorateHelper); return setTextRange( createCall( - getHelperName("__param"), + getHelperName("__decorate"), /*typeArguments*/ undefined, - [ - createLiteral(parameterOffset), - expression - ] + argumentsArray ), location ); } - const metadataHelper: EmitHelper = { - name: "typescript:metadata", + const decorateHelper: EmitHelper = { + name: "typescript:decorate", scoped: false, - priority: 3, + priority: 2, text: ` - var __metadata = (this && this.__metadata) || function (k, v) { - if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); + var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; };` }; @@ -3387,38 +3402,38 @@ namespace ts { ); } - const decorateHelper: EmitHelper = { - name: "typescript:decorate", + const metadataHelper: EmitHelper = { + name: "typescript:metadata", scoped: false, - priority: 2, + priority: 3, text: ` - var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); - else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; - return c > 3 && r && Object.defineProperty(target, key, r), r; + var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); };` }; - function createDecorateHelper(context: TransformationContext, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) { - context.requestEmitHelper(decorateHelper); - const argumentsArray: Expression[] = []; - argumentsArray.push(createArrayLiteral(decoratorExpressions, /*multiLine*/ true)); - argumentsArray.push(target); - if (memberName) { - argumentsArray.push(memberName); - if (descriptor) { - argumentsArray.push(descriptor); - } - } - + function createParamHelper(context: TransformationContext, expression: Expression, parameterOffset: number, location?: TextRange) { + context.requestEmitHelper(paramHelper); return setTextRange( createCall( - getHelperName("__decorate"), + getHelperName("__param"), /*typeArguments*/ undefined, - argumentsArray + [ + createLiteral(parameterOffset), + expression + ] ), location ); } + + const paramHelper: EmitHelper = { + name: "typescript:param", + scoped: false, + priority: 4, + text: ` + var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } + };` + }; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 7fc77b487088c..80e32608c8f4b 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -542,6 +542,7 @@ export type EndOfFileToken = Token; export type AtToken = Token; export type ReadonlyToken = Token; + export type AwaitKeywordToken = Token; export type Modifier = Token @@ -699,7 +700,13 @@ name?: PropertyName; } - export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration | SpreadAssignment; + export type ObjectLiteralElementLike + = PropertyAssignment + | ShorthandPropertyAssignment + | SpreadAssignment + | MethodDeclaration + | AccessorDeclaration + ; export interface PropertyAssignment extends ObjectLiteralElement { kind: SyntaxKind.PropertyAssignment; @@ -1637,6 +1644,7 @@ export interface ForOfStatement extends IterationStatement { kind: SyntaxKind.ForOfStatement; + awaitModifier?: AwaitKeywordToken; initializer: ForInitializer; expression: Expression; } @@ -3058,8 +3066,17 @@ // Just a place to cache element types of iterables and iterators /* @internal */ export interface IterableOrIteratorType extends ObjectType, UnionType { - iterableElementType?: Type; - iteratorElementType?: Type; + iteratedTypeOfIterable?: Type; + iteratedTypeOfIterator?: Type; + iteratedTypeOfAsyncIterable?: Type; + iteratedTypeOfAsyncIterator?: Type; + } + + /* @internal */ + export interface PromiseOrAwaitableType extends ObjectType, UnionType { + promiseTypeOfPromiseConstructor?: Type; + promisedTypeOfPromise?: Type; + awaitedTypeOfType?: Type; } export interface TypeVariable extends Type { @@ -3253,6 +3270,7 @@ /* @internal */ diagnostics?: boolean; /* @internal */ extendedDiagnostics?: boolean; disableSizeLimit?: boolean; + downlevelIteration?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; @@ -3828,9 +3846,24 @@ Param = 1 << 5, // __param (used by TypeScript decorators transformation) Awaiter = 1 << 6, // __awaiter (used by ES2017 async functions transformation) Generator = 1 << 7, // __generator (used by ES2015 generator transformation) + Values = 1 << 8, // __values (used by ES2015 for..of and yield* transformations) + Read = 1 << 9, // __read (used by ES2015 iterator destructuring transformation) + Spread = 1 << 10, // __spread (used by ES2015 array spread and argument list spread transformations) + AsyncGenerator = 1 << 11, // __asyncGenerator (used by ES2017 async generator transformation) + AsyncDelegator = 1 << 12, // __asyncDelegator (used by ES2017 async generator yield* transformation) + AsyncValues = 1 << 13, // __asyncValues (used by ES2017 for..await..of transformation) + + // Helpers included by ES2015 for..of + ForOfIncludes = Values, + + // Helpers included by ES2017 for..await..of + ForAwaitOfIncludes = AsyncValues, + + // Helpers included by ES2015 spread + SpreadIncludes = Read | Spread, FirstEmitHelper = Extends, - LastEmitHelper = Generator + LastEmitHelper = AsyncValues } export const enum EmitHint { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 97137090d3881..6dd9f796c897e 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -960,7 +960,7 @@ namespace ts { return false; } - export function unwrapInnermostStatmentOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) { + export function unwrapInnermostStatementOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) { while (true) { if (beforeUnwrapLabelCallback) { beforeUnwrapLabelCallback(node); @@ -1950,8 +1950,51 @@ namespace ts { return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken; } - export function isAsyncFunctionLike(node: Node): boolean { - return isFunctionLike(node) && hasModifier(node, ModifierFlags.Async) && !isAccessor(node); + export const enum FunctionFlags { + Normal = 0, + Generator = 1 << 0, + Async = 1 << 1, + AsyncOrAsyncGenerator = Async | Generator, + Invalid = 1 << 2, + InvalidAsyncOrAsyncGenerator = AsyncOrAsyncGenerator | Invalid, + InvalidGenerator = Generator | Invalid, + } + + export function getFunctionFlags(node: FunctionLikeDeclaration) { + let flags = FunctionFlags.Normal; + switch (node.kind) { + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + case SyntaxKind.MethodDeclaration: + if (node.asteriskToken) { + flags |= FunctionFlags.Generator; + } + // fall through + case SyntaxKind.ArrowFunction: + if (hasModifier(node, ModifierFlags.Async)) { + flags |= FunctionFlags.Async; + } + break; + } + + if (!node.body) { + flags |= FunctionFlags.Invalid; + } + + return flags; + } + + export function isAsyncFunction(node: Node): boolean { + switch (node.kind) { + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + case SyntaxKind.MethodDeclaration: + return (node).body !== undefined + && (node).asteriskToken === undefined + && hasModifier(node, ModifierFlags.Async); + } + return false; } export function isStringOrNumericLiteral(node: Node): node is StringLiteral | NumericLiteral { @@ -4170,7 +4213,6 @@ namespace ts { return "lib.es2016.d.ts"; case ScriptTarget.ES2015: return "lib.es6.d.ts"; - default: return "lib.d.ts"; } diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts index 7ca71aec0d0cd..1d9071231fa6a 100644 --- a/src/compiler/visitor.ts +++ b/src/compiler/visitor.ts @@ -4,7 +4,7 @@ /* @internal */ namespace ts { - export type VisitResult = T | T[]; + export type VisitResult = T[] | T | undefined; function reduceNode(node: Node, f: (memo: T, node: Node) => T, initial: T) { return node ? f(initial, node) : initial; @@ -725,6 +725,7 @@ namespace ts { return updateMethod(node, visitNodes((node).decorators, visitor, isDecorator), visitNodes((node).modifiers, visitor, isModifier), + (node).asteriskToken, visitNode((node).name, visitor, isPropertyName), visitNodes((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context), @@ -819,6 +820,7 @@ namespace ts { case SyntaxKind.FunctionExpression: return updateFunctionExpression(node, visitNodes((node).modifiers, visitor, isModifier), + (node).asteriskToken, visitNode((node).name, visitor, isPropertyName), visitNodes((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context), @@ -954,6 +956,7 @@ namespace ts { case SyntaxKind.ForOfStatement: return updateForOf(node, + (node).awaitModifier, visitNode((node).initializer, visitor, isForInitializer), visitNode((node).expression, visitor, isExpression), visitNode((node).statement, visitor, isStatement, /*optional*/ false, liftToBlock)); @@ -1009,6 +1012,7 @@ namespace ts { return updateFunctionDeclaration(node, visitNodes((node).decorators, visitor, isDecorator), visitNodes((node).modifiers, visitor, isModifier), + (node).asteriskToken, visitNode((node).name, visitor, isPropertyName), visitNodes((node).typeParameters, visitor, isTypeParameter), visitParameterList((node).parameters, visitor, context), @@ -1199,9 +1203,10 @@ namespace ts { } /** - * Merges generated lexical declarations into a new statement list. + * Merges generated lexical declarations into a statement list, creating a new statement list. */ export function mergeLexicalEnvironment(statements: NodeArray, declarations: Statement[]): NodeArray; + /** * Appends generated lexical declarations to an array of statements. */ @@ -1210,49 +1215,12 @@ namespace ts { if (!some(declarations)) { return statements; } + return isNodeArray(statements) ? setTextRange(createNodeArray(concatenate(statements, declarations)), statements) : addRange(statements, declarations); } - - /** - * Merges generated lexical declarations into the FunctionBody of a non-arrow function-like declaration. - * - * @param node The ConciseBody of an arrow function. - * @param declarations The lexical declarations to merge. - */ - export function mergeFunctionBodyLexicalEnvironment(body: FunctionBody, declarations: Statement[]): FunctionBody; - - /** - * Merges generated lexical declarations into the ConciseBody of an ArrowFunction. - * - * @param node The ConciseBody of an arrow function. - * @param declarations The lexical declarations to merge. - */ - export function mergeFunctionBodyLexicalEnvironment(body: ConciseBody, declarations: Statement[]): ConciseBody; - - export function mergeFunctionBodyLexicalEnvironment(body: ConciseBody, declarations: Statement[]): ConciseBody { - if (body && declarations !== undefined && declarations.length > 0) { - if (isBlock(body)) { - return updateBlock(body, setTextRange(createNodeArray(concatenate(body.statements, declarations)), body.statements)); - } - else { - return setTextRange( - createBlock( - setTextRange( - createNodeArray([setTextRange(createReturn(body), body), ...declarations]), - body - ), - /*multiLine*/ true - ), - /*location*/ body - ); - } - } - return body; - } - /** * Lifts a NodeArray containing only Statement nodes to a block. * diff --git a/src/harness/unittests/commandLineParsing.ts b/src/harness/unittests/commandLineParsing.ts index 1895fe2d60e81..8e5ed5f353469 100644 --- a/src/harness/unittests/commandLineParsing.ts +++ b/src/harness/unittests/commandLineParsing.ts @@ -60,7 +60,7 @@ namespace ts { assertParseResult(["--lib", "es5,invalidOption", "0.ts"], { errors: [{ - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category, code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code, @@ -263,7 +263,7 @@ namespace ts { assertParseResult(["--lib", "es5,", "es7", "0.ts"], { errors: [{ - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category, code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code, @@ -283,7 +283,7 @@ namespace ts { assertParseResult(["--lib", "es5, ", "es7", "0.ts"], { errors: [{ - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category, code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code, diff --git a/src/harness/unittests/convertCompilerOptionsFromJson.ts b/src/harness/unittests/convertCompilerOptionsFromJson.ts index 4e44217388306..26ca8e26df13b 100644 --- a/src/harness/unittests/convertCompilerOptionsFromJson.ts +++ b/src/harness/unittests/convertCompilerOptionsFromJson.ts @@ -233,7 +233,7 @@ namespace ts { file: undefined, start: 0, length: 0, - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code, category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category }] @@ -264,7 +264,7 @@ namespace ts { file: undefined, start: 0, length: 0, - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code, category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category }] @@ -295,7 +295,7 @@ namespace ts { file: undefined, start: 0, length: 0, - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code, category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category }] @@ -326,7 +326,7 @@ namespace ts { file: undefined, start: 0, length: 0, - messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'", + messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'", code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code, category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category }] diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index c8b5158bcd655..247017bae7d00 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -1,8 +1,8 @@ /// interface SymbolConstructor { - /** - * A method that returns the default iterator for an object. Called by the semantics of the + /** + * A method that returns the default iterator for an object. Called by the semantics of the * for-of statement. */ readonly iterator: symbol; @@ -31,17 +31,17 @@ interface Array { /** Iterator */ [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, T]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -55,7 +55,7 @@ interface ArrayConstructor { * @param thisArg Value of 'this' used to invoke the mapfn. */ from(iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): Array; - + /** * Creates an array from an iterable object. * @param iterable An iterable object to convert to an array. @@ -67,17 +67,17 @@ interface ReadonlyArray { /** Iterator */ [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, T]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -126,15 +126,15 @@ interface Promise { } interface PromiseConstructor { /** - * Creates a Promise that is resolved with an array of results when all of the provided Promises + * Creates a Promise that is resolved with an array of results when all of the provided Promises * resolve, or rejected when any Promise is rejected. * @param values An array of Promises. * @returns A new Promise. */ all(values: Iterable>): Promise; - + /** - * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved + * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved * or rejected. * @param values An array of Promises. * @returns A new Promise. @@ -152,20 +152,20 @@ interface String { } /** - * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested + * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested * number of bytes could not be allocated an exception is raised. */ interface Int8Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -184,20 +184,20 @@ interface Int8ArrayConstructor { } /** - * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the + * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ interface Uint8Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -216,22 +216,22 @@ interface Uint8ArrayConstructor { } /** - * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. + * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. * If the requested number of bytes could not be allocated an exception is raised. */ interface Uint8ClampedArray { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -251,22 +251,22 @@ interface Uint8ClampedArrayConstructor { } /** - * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the + * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ interface Int16Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -285,20 +285,20 @@ interface Int16ArrayConstructor { } /** - * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the + * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ interface Uint16Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -317,20 +317,20 @@ interface Uint16ArrayConstructor { } /** - * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the + * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ interface Int32Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -349,20 +349,20 @@ interface Int32ArrayConstructor { } /** - * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the + * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ interface Uint32Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -386,15 +386,15 @@ interface Uint32ArrayConstructor { */ interface Float32Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; @@ -413,20 +413,20 @@ interface Float32ArrayConstructor { } /** - * A typed array of 64-bit float values. The contents are initialized to 0. If the requested + * A typed array of 64-bit float values. The contents are initialized to 0. If the requested * number of bytes could not be allocated an exception is raised. */ interface Float64Array { [Symbol.iterator](): IterableIterator; - /** + /** * Returns an array of key, value pairs for every entry in the array */ entries(): IterableIterator<[number, number]>; - /** + /** * Returns an list of keys in the array */ keys(): IterableIterator; - /** + /** * Returns an list of values in the array */ values(): IterableIterator; diff --git a/src/lib/es2017.d.ts b/src/lib/es2017.d.ts index c234a9edb249f..7b8c7cbb7d5be 100644 --- a/src/lib/es2017.d.ts +++ b/src/lib/es2017.d.ts @@ -1,4 +1,4 @@ /// /// /// -/// +/// \ No newline at end of file diff --git a/src/lib/esnext.asynciterable.d.ts b/src/lib/esnext.asynciterable.d.ts new file mode 100644 index 0000000000000..8379ba5ba6cd0 --- /dev/null +++ b/src/lib/esnext.asynciterable.d.ts @@ -0,0 +1,24 @@ +/// +/// + +interface SymbolConstructor { + /** + * A method that returns the default async iterator for an object. Called by the semantics of + * the for-await-of statement. + */ + readonly asyncIterator: symbol; +} + +interface AsyncIterator { + next(value?: any): Promise>; + return?(value?: any): Promise>; + throw?(e?: any): Promise>; +} + +interface AsyncIterable { + [Symbol.asyncIterator](): AsyncIterator; +} + +interface AsyncIterableIterator extends AsyncIterator { + [Symbol.asyncIterator](): AsyncIterableIterator; +} \ No newline at end of file diff --git a/src/lib/esnext.d.ts b/src/lib/esnext.d.ts new file mode 100644 index 0000000000000..71fab82a866bc --- /dev/null +++ b/src/lib/esnext.d.ts @@ -0,0 +1,2 @@ +/// +/// diff --git a/tests/baselines/reference/ES5For-of33.errors.txt b/tests/baselines/reference/ES5For-of33.errors.txt new file mode 100644 index 0000000000000..02ba889c542fb --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts(2,5): error TS2304: Cannot find name 'console'. + + +==== tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts (1 errors) ==== + for (var v of ['a', 'b', 'c']) { + console.log(v); + ~~~~~~~ +!!! error TS2304: Cannot find name 'console'. + } \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of33.js b/tests/baselines/reference/ES5For-of33.js new file mode 100644 index 0000000000000..729c37b8120d8 --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.js @@ -0,0 +1,31 @@ +//// [ES5For-of33.ts] +for (var v of ['a', 'b', 'c']) { + console.log(v); +} + +//// [ES5For-of33.js] +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +try { + for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) { + var v = _b.value; + console.log(v); + } +} +catch (e_1_1) { e_1 = { error: e_1_1 }; } +finally { + try { + if (_b && !_b.done && (_c = _a["return"])) _c.call(_a); + } + finally { if (e_1) throw e_1.error; } +} +var e_1, _c; +//# sourceMappingURL=ES5For-of33.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of33.js.map b/tests/baselines/reference/ES5For-of33.js.map new file mode 100644 index 0000000000000..5d5969b45854a --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.js.map @@ -0,0 +1,2 @@ +//// [ES5For-of33.js.map] +{"version":3,"file":"ES5For-of33.js","sourceRoot":"","sources":["ES5For-of33.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA,GAAG,CAAC,CAAU,IAAA,KAAA,SAAA,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA,gBAAA;QAAxB,IAAI,CAAC,WAAA;QACN,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAClB"} \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of33.sourcemap.txt b/tests/baselines/reference/ES5For-of33.sourcemap.txt new file mode 100644 index 0000000000000..12dd243cf0ec9 --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.sourcemap.txt @@ -0,0 +1,128 @@ +=================================================================== +JsFile: ES5For-of33.js +mapUrl: ES5For-of33.js.map +sourceRoot: +sources: ES5For-of33.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of33.js +sourceFile:ES5For-of33.ts +------------------------------------------------------------------- +>>>var __values = (this && this.__values) || function (o) { +>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; +>>> if (m) return m.call(o); +>>> return { +>>> next: function () { +>>> if (o && i >= o.length) o = void 0; +>>> return { value: o && o[i++], done: !o }; +>>> } +>>> }; +>>>}; +>>>try { +>>> for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) { +1 >^^^^ +2 > ^^^ +3 > ^ +4 > ^ +5 > ^^^^ +6 > ^^^^^ +7 > ^^^^^^^^^ +8 > ^ +9 > ^^^ +10> ^^ +11> ^^^ +12> ^^ +13> ^^^ +14> ^ +15> ^ +16> ^^^^^^^^^^^^^^^^ +1 > +2 > for +3 > +4 > (var v of +5 > +6 > +7 > +8 > [ +9 > 'a' +10> , +11> 'b' +12> , +13> 'c' +14> ] +15> +16> +1 >Emitted(12, 5) Source(1, 1) + SourceIndex(0) +2 >Emitted(12, 8) Source(1, 4) + SourceIndex(0) +3 >Emitted(12, 9) Source(1, 5) + SourceIndex(0) +4 >Emitted(12, 10) Source(1, 15) + SourceIndex(0) +5 >Emitted(12, 14) Source(1, 15) + SourceIndex(0) +6 >Emitted(12, 19) Source(1, 15) + SourceIndex(0) +7 >Emitted(12, 28) Source(1, 15) + SourceIndex(0) +8 >Emitted(12, 29) Source(1, 16) + SourceIndex(0) +9 >Emitted(12, 32) Source(1, 19) + SourceIndex(0) +10>Emitted(12, 34) Source(1, 21) + SourceIndex(0) +11>Emitted(12, 37) Source(1, 24) + SourceIndex(0) +12>Emitted(12, 39) Source(1, 26) + SourceIndex(0) +13>Emitted(12, 42) Source(1, 29) + SourceIndex(0) +14>Emitted(12, 43) Source(1, 30) + SourceIndex(0) +15>Emitted(12, 44) Source(1, 30) + SourceIndex(0) +16>Emitted(12, 60) Source(1, 30) + SourceIndex(0) +--- +>>> var v = _b.value; +1 >^^^^^^^^ +2 > ^^^^ +3 > ^ +4 > ^^^^^^^^^^^ +1 > +2 > var +3 > v +4 > +1 >Emitted(13, 9) Source(1, 6) + SourceIndex(0) +2 >Emitted(13, 13) Source(1, 10) + SourceIndex(0) +3 >Emitted(13, 14) Source(1, 11) + SourceIndex(0) +4 >Emitted(13, 25) Source(1, 11) + SourceIndex(0) +--- +>>> console.log(v); +1 >^^^^^^^^ +2 > ^^^^^^^ +3 > ^ +4 > ^^^ +5 > ^ +6 > ^ +7 > ^ +8 > ^ +1 > of ['a', 'b', 'c']) { + > +2 > console +3 > . +4 > log +5 > ( +6 > v +7 > ) +8 > ; +1 >Emitted(14, 9) Source(2, 5) + SourceIndex(0) +2 >Emitted(14, 16) Source(2, 12) + SourceIndex(0) +3 >Emitted(14, 17) Source(2, 13) + SourceIndex(0) +4 >Emitted(14, 20) Source(2, 16) + SourceIndex(0) +5 >Emitted(14, 21) Source(2, 17) + SourceIndex(0) +6 >Emitted(14, 22) Source(2, 18) + SourceIndex(0) +7 >Emitted(14, 23) Source(2, 19) + SourceIndex(0) +8 >Emitted(14, 24) Source(2, 20) + SourceIndex(0) +--- +>>> } +1 >^^^^^ +1 > + >} +1 >Emitted(15, 6) Source(3, 2) + SourceIndex(0) +--- +>>>} +>>>catch (e_1_1) { e_1 = { error: e_1_1 }; } +>>>finally { +>>> try { +>>> if (_b && !_b.done && (_c = _a["return"])) _c.call(_a); +>>> } +>>> finally { if (e_1) throw e_1.error; } +>>>} +>>>var e_1, _c; +>>>//# sourceMappingURL=ES5For-of33.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of34.errors.txt b/tests/baselines/reference/ES5For-of34.errors.txt new file mode 100644 index 0000000000000..46f9666f7766f --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.errors.txt @@ -0,0 +1,12 @@ +tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts(4,6): error TS2322: Type 'string' is not assignable to type 'number'. + + +==== tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts (1 errors) ==== + function foo() { + return { x: 0 }; + } + for (foo().x of ['a', 'b', 'c']) { + ~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + var p = foo().x; + } \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of34.js b/tests/baselines/reference/ES5For-of34.js new file mode 100644 index 0000000000000..307a7505d09b7 --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.js @@ -0,0 +1,37 @@ +//// [ES5For-of34.ts] +function foo() { + return { x: 0 }; +} +for (foo().x of ['a', 'b', 'c']) { + var p = foo().x; +} + +//// [ES5For-of34.js] +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +function foo() { + return { x: 0 }; +} +try { + for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) { + foo().x = _b.value; + var p = foo().x; + } +} +catch (e_1_1) { e_1 = { error: e_1_1 }; } +finally { + try { + if (_b && !_b.done && (_c = _a["return"])) _c.call(_a); + } + finally { if (e_1) throw e_1.error; } +} +var e_1, _c; +//# sourceMappingURL=ES5For-of34.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of34.js.map b/tests/baselines/reference/ES5For-of34.js.map new file mode 100644 index 0000000000000..041fda734b5d9 --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.js.map @@ -0,0 +1,2 @@ +//// [ES5For-of34.js.map] +{"version":3,"file":"ES5For-of34.js","sourceRoot":"","sources":["ES5For-of34.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;IACI,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACpB,CAAC;;IACD,GAAG,CAAC,CAAY,IAAA,KAAA,SAAA,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA,gBAAA;QAA1B,GAAG,EAAE,CAAC,CAAC,WAAA;QACR,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;KACnB"} \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of34.sourcemap.txt b/tests/baselines/reference/ES5For-of34.sourcemap.txt new file mode 100644 index 0000000000000..540d52cc58149 --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.sourcemap.txt @@ -0,0 +1,184 @@ +=================================================================== +JsFile: ES5For-of34.js +mapUrl: ES5For-of34.js.map +sourceRoot: +sources: ES5For-of34.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of34.js +sourceFile:ES5For-of34.ts +------------------------------------------------------------------- +>>>var __values = (this && this.__values) || function (o) { +>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; +>>> if (m) return m.call(o); +>>> return { +>>> next: function () { +>>> if (o && i >= o.length) o = void 0; +>>> return { value: o && o[i++], done: !o }; +>>> } +>>> }; +>>>}; +>>>function foo() { +1 > +2 >^^^^^^^^^^^^^^^^^^^^^-> +1 > +1 >Emitted(11, 1) Source(1, 1) + SourceIndex(0) +--- +>>> return { x: 0 }; +1->^^^^ +2 > ^^^^^^ +3 > ^ +4 > ^^ +5 > ^ +6 > ^^ +7 > ^ +8 > ^^ +9 > ^ +1->function foo() { + > +2 > return +3 > +4 > { +5 > x +6 > : +7 > 0 +8 > } +9 > ; +1->Emitted(12, 5) Source(2, 5) + SourceIndex(0) +2 >Emitted(12, 11) Source(2, 11) + SourceIndex(0) +3 >Emitted(12, 12) Source(2, 12) + SourceIndex(0) +4 >Emitted(12, 14) Source(2, 14) + SourceIndex(0) +5 >Emitted(12, 15) Source(2, 15) + SourceIndex(0) +6 >Emitted(12, 17) Source(2, 17) + SourceIndex(0) +7 >Emitted(12, 18) Source(2, 18) + SourceIndex(0) +8 >Emitted(12, 20) Source(2, 20) + SourceIndex(0) +9 >Emitted(12, 21) Source(2, 21) + SourceIndex(0) +--- +>>>} +1 > +2 >^ +3 > ^^^^^-> +1 > + > +2 >} +1 >Emitted(13, 1) Source(3, 1) + SourceIndex(0) +2 >Emitted(13, 2) Source(3, 2) + SourceIndex(0) +--- +>>>try { +>>> for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) { +1->^^^^ +2 > ^^^ +3 > ^ +4 > ^ +5 > ^^^^ +6 > ^^^^^ +7 > ^^^^^^^^^ +8 > ^ +9 > ^^^ +10> ^^ +11> ^^^ +12> ^^ +13> ^^^ +14> ^ +15> ^ +16> ^^^^^^^^^^^^^^^^ +1-> + > +2 > for +3 > +4 > (foo().x of +5 > +6 > +7 > +8 > [ +9 > 'a' +10> , +11> 'b' +12> , +13> 'c' +14> ] +15> +16> +1->Emitted(15, 5) Source(4, 1) + SourceIndex(0) +2 >Emitted(15, 8) Source(4, 4) + SourceIndex(0) +3 >Emitted(15, 9) Source(4, 5) + SourceIndex(0) +4 >Emitted(15, 10) Source(4, 17) + SourceIndex(0) +5 >Emitted(15, 14) Source(4, 17) + SourceIndex(0) +6 >Emitted(15, 19) Source(4, 17) + SourceIndex(0) +7 >Emitted(15, 28) Source(4, 17) + SourceIndex(0) +8 >Emitted(15, 29) Source(4, 18) + SourceIndex(0) +9 >Emitted(15, 32) Source(4, 21) + SourceIndex(0) +10>Emitted(15, 34) Source(4, 23) + SourceIndex(0) +11>Emitted(15, 37) Source(4, 26) + SourceIndex(0) +12>Emitted(15, 39) Source(4, 28) + SourceIndex(0) +13>Emitted(15, 42) Source(4, 31) + SourceIndex(0) +14>Emitted(15, 43) Source(4, 32) + SourceIndex(0) +15>Emitted(15, 44) Source(4, 32) + SourceIndex(0) +16>Emitted(15, 60) Source(4, 32) + SourceIndex(0) +--- +>>> foo().x = _b.value; +1 >^^^^^^^^ +2 > ^^^ +3 > ^^ +4 > ^ +5 > ^ +6 > ^^^^^^^^^^^ +1 > +2 > foo +3 > () +4 > . +5 > x +6 > +1 >Emitted(16, 9) Source(4, 6) + SourceIndex(0) +2 >Emitted(16, 12) Source(4, 9) + SourceIndex(0) +3 >Emitted(16, 14) Source(4, 11) + SourceIndex(0) +4 >Emitted(16, 15) Source(4, 12) + SourceIndex(0) +5 >Emitted(16, 16) Source(4, 13) + SourceIndex(0) +6 >Emitted(16, 27) Source(4, 13) + SourceIndex(0) +--- +>>> var p = foo().x; +1 >^^^^^^^^ +2 > ^^^^ +3 > ^ +4 > ^^^ +5 > ^^^ +6 > ^^ +7 > ^ +8 > ^ +9 > ^ +1 > of ['a', 'b', 'c']) { + > +2 > var +3 > p +4 > = +5 > foo +6 > () +7 > . +8 > x +9 > ; +1 >Emitted(17, 9) Source(5, 5) + SourceIndex(0) +2 >Emitted(17, 13) Source(5, 9) + SourceIndex(0) +3 >Emitted(17, 14) Source(5, 10) + SourceIndex(0) +4 >Emitted(17, 17) Source(5, 13) + SourceIndex(0) +5 >Emitted(17, 20) Source(5, 16) + SourceIndex(0) +6 >Emitted(17, 22) Source(5, 18) + SourceIndex(0) +7 >Emitted(17, 23) Source(5, 19) + SourceIndex(0) +8 >Emitted(17, 24) Source(5, 20) + SourceIndex(0) +9 >Emitted(17, 25) Source(5, 21) + SourceIndex(0) +--- +>>> } +1 >^^^^^ +1 > + >} +1 >Emitted(18, 6) Source(6, 2) + SourceIndex(0) +--- +>>>} +>>>catch (e_1_1) { e_1 = { error: e_1_1 }; } +>>>finally { +>>> try { +>>> if (_b && !_b.done && (_c = _a["return"])) _c.call(_a); +>>> } +>>> finally { if (e_1) throw e_1.error; } +>>>} +>>>var e_1, _c; +>>>//# sourceMappingURL=ES5For-of34.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of35.errors.txt b/tests/baselines/reference/ES5For-of35.errors.txt new file mode 100644 index 0000000000000..8c43d9598888d --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts(1,13): error TS2459: Type 'number' has no property 'x' and no string index signature. +tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts(1,23): error TS2459: Type 'number' has no property 'y' and no string index signature. + + +==== tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts (2 errors) ==== + for (const {x: a = 0, y: b = 1} of [2, 3]) { + ~ +!!! error TS2459: Type 'number' has no property 'x' and no string index signature. + ~ +!!! error TS2459: Type 'number' has no property 'y' and no string index signature. + a; + b; + } \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of35.js b/tests/baselines/reference/ES5For-of35.js new file mode 100644 index 0000000000000..597296cacaedd --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.js @@ -0,0 +1,33 @@ +//// [ES5For-of35.ts] +for (const {x: a = 0, y: b = 1} of [2, 3]) { + a; + b; +} + +//// [ES5For-of35.js] +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +try { + for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) { + var _c = _b.value, _d = _c.x, a = _d === void 0 ? 0 : _d, _e = _c.y, b = _e === void 0 ? 1 : _e; + a; + b; + } +} +catch (e_1_1) { e_1 = { error: e_1_1 }; } +finally { + try { + if (_b && !_b.done && (_f = _a["return"])) _f.call(_a); + } + finally { if (e_1) throw e_1.error; } +} +var e_1, _f; +//# sourceMappingURL=ES5For-of35.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of35.js.map b/tests/baselines/reference/ES5For-of35.js.map new file mode 100644 index 0000000000000..f1ee2418d179f --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.js.map @@ -0,0 +1,2 @@ +//// [ES5For-of35.js.map] +{"version":3,"file":"ES5For-of35.js","sourceRoot":"","sources":["ES5For-of35.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA,GAAG,CAAC,CAA+B,IAAA,KAAA,SAAA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA,gBAAA;QAA9B,IAAA,aAAoB,EAAnB,SAAQ,EAAR,0BAAQ,EAAE,SAAQ,EAAR,0BAAQ;QAC1B,CAAC,CAAC;QACF,CAAC,CAAC;KACL"} \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of35.sourcemap.txt b/tests/baselines/reference/ES5For-of35.sourcemap.txt new file mode 100644 index 0000000000000..1961188da49f2 --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.sourcemap.txt @@ -0,0 +1,142 @@ +=================================================================== +JsFile: ES5For-of35.js +mapUrl: ES5For-of35.js.map +sourceRoot: +sources: ES5For-of35.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of35.js +sourceFile:ES5For-of35.ts +------------------------------------------------------------------- +>>>var __values = (this && this.__values) || function (o) { +>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; +>>> if (m) return m.call(o); +>>> return { +>>> next: function () { +>>> if (o && i >= o.length) o = void 0; +>>> return { value: o && o[i++], done: !o }; +>>> } +>>> }; +>>>}; +>>>try { +>>> for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) { +1 >^^^^ +2 > ^^^ +3 > ^ +4 > ^ +5 > ^^^^ +6 > ^^^^^ +7 > ^^^^^^^^^ +8 > ^ +9 > ^ +10> ^^ +11> ^ +12> ^ +13> ^ +14> ^^^^^^^^^^^^^^^^ +15> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > +2 > for +3 > +4 > (const {x: a = 0, y: b = 1} of +5 > +6 > +7 > +8 > [ +9 > 2 +10> , +11> 3 +12> ] +13> +14> +1 >Emitted(12, 5) Source(1, 1) + SourceIndex(0) +2 >Emitted(12, 8) Source(1, 4) + SourceIndex(0) +3 >Emitted(12, 9) Source(1, 5) + SourceIndex(0) +4 >Emitted(12, 10) Source(1, 36) + SourceIndex(0) +5 >Emitted(12, 14) Source(1, 36) + SourceIndex(0) +6 >Emitted(12, 19) Source(1, 36) + SourceIndex(0) +7 >Emitted(12, 28) Source(1, 36) + SourceIndex(0) +8 >Emitted(12, 29) Source(1, 37) + SourceIndex(0) +9 >Emitted(12, 30) Source(1, 38) + SourceIndex(0) +10>Emitted(12, 32) Source(1, 40) + SourceIndex(0) +11>Emitted(12, 33) Source(1, 41) + SourceIndex(0) +12>Emitted(12, 34) Source(1, 42) + SourceIndex(0) +13>Emitted(12, 35) Source(1, 42) + SourceIndex(0) +14>Emitted(12, 51) Source(1, 42) + SourceIndex(0) +--- +>>> var _c = _b.value, _d = _c.x, a = _d === void 0 ? 0 : _d, _e = _c.y, b = _e === void 0 ? 1 : _e; +1->^^^^^^^^ +2 > ^^^^ +3 > ^^^^^^^^^^^^^ +4 > ^^ +5 > ^^^^^^^^^ +6 > ^^ +7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ +8 > ^^ +9 > ^^^^^^^^^ +10> ^^ +11> ^^^^^^^^^^^^^^^^^^^^^^^^^^ +1-> +2 > +3 > {x: a = 0, y: b = 1} +4 > +5 > x: a = 0 +6 > +7 > x: a = 0 +8 > , +9 > y: b = 1 +10> +11> y: b = 1 +1->Emitted(13, 9) Source(1, 12) + SourceIndex(0) +2 >Emitted(13, 13) Source(1, 12) + SourceIndex(0) +3 >Emitted(13, 26) Source(1, 32) + SourceIndex(0) +4 >Emitted(13, 28) Source(1, 13) + SourceIndex(0) +5 >Emitted(13, 37) Source(1, 21) + SourceIndex(0) +6 >Emitted(13, 39) Source(1, 13) + SourceIndex(0) +7 >Emitted(13, 65) Source(1, 21) + SourceIndex(0) +8 >Emitted(13, 67) Source(1, 23) + SourceIndex(0) +9 >Emitted(13, 76) Source(1, 31) + SourceIndex(0) +10>Emitted(13, 78) Source(1, 23) + SourceIndex(0) +11>Emitted(13, 104) Source(1, 31) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 >} of [2, 3]) { + > +2 > a +3 > ; +1 >Emitted(14, 9) Source(2, 5) + SourceIndex(0) +2 >Emitted(14, 10) Source(2, 6) + SourceIndex(0) +3 >Emitted(14, 11) Source(2, 7) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(15, 9) Source(3, 5) + SourceIndex(0) +2 >Emitted(15, 10) Source(3, 6) + SourceIndex(0) +3 >Emitted(15, 11) Source(3, 7) + SourceIndex(0) +--- +>>> } +1 >^^^^^ +1 > + >} +1 >Emitted(16, 6) Source(4, 2) + SourceIndex(0) +--- +>>>} +>>>catch (e_1_1) { e_1 = { error: e_1_1 }; } +>>>finally { +>>> try { +>>> if (_b && !_b.done && (_f = _a["return"])) _f.call(_a); +>>> } +>>> finally { if (e_1) throw e_1.error; } +>>>} +>>>var e_1, _f; +>>>//# sourceMappingURL=ES5For-of35.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of36.errors.txt b/tests/baselines/reference/ES5For-of36.errors.txt new file mode 100644 index 0000000000000..86a40dcffa547 --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts(1,10): error TS2548: Type 'number' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts (1 errors) ==== + for (let [a = 0, b = 1] of [2, 3]) { + ~~~~~~~~~~~~~~ +!!! error TS2548: Type 'number' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator. + a; + b; + } \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of36.js b/tests/baselines/reference/ES5For-of36.js new file mode 100644 index 0000000000000..fca89ee922b84 --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.js @@ -0,0 +1,49 @@ +//// [ES5For-of36.ts] +for (let [a = 0, b = 1] of [2, 3]) { + a; + b; +} + +//// [ES5For-of36.js] +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +try { + for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) { + var _c = __read(_b.value, 2), _d = _c[0], a = _d === void 0 ? 0 : _d, _e = _c[1], b = _e === void 0 ? 1 : _e; + a; + b; + } +} +catch (e_1_1) { e_1 = { error: e_1_1 }; } +finally { + try { + if (_b && !_b.done && (_f = _a["return"])) _f.call(_a); + } + finally { if (e_1) throw e_1.error; } +} +var e_1, _f; +//# sourceMappingURL=ES5For-of36.js.map \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of36.js.map b/tests/baselines/reference/ES5For-of36.js.map new file mode 100644 index 0000000000000..f53bc850818a5 --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.js.map @@ -0,0 +1,2 @@ +//// [ES5For-of36.js.map] +{"version":3,"file":"ES5For-of36.js","sourceRoot":"","sources":["ES5For-of36.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA,GAAG,CAAC,CAAuB,IAAA,KAAA,SAAA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA,gBAAA;QAAxB,IAAA,wBAAc,EAAb,UAAK,EAAL,0BAAK,EAAE,UAAK,EAAL,0BAAK;QAClB,CAAC,CAAC;QACF,CAAC,CAAC;KACL"} \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of36.sourcemap.txt b/tests/baselines/reference/ES5For-of36.sourcemap.txt new file mode 100644 index 0000000000000..4b16e02b3b10a --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.sourcemap.txt @@ -0,0 +1,158 @@ +=================================================================== +JsFile: ES5For-of36.js +mapUrl: ES5For-of36.js.map +sourceRoot: +sources: ES5For-of36.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of36.js +sourceFile:ES5For-of36.ts +------------------------------------------------------------------- +>>>var __values = (this && this.__values) || function (o) { +>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; +>>> if (m) return m.call(o); +>>> return { +>>> next: function () { +>>> if (o && i >= o.length) o = void 0; +>>> return { value: o && o[i++], done: !o }; +>>> } +>>> }; +>>>}; +>>>var __read = (this && this.__read) || function (o, n) { +>>> var m = typeof Symbol === "function" && o[Symbol.iterator]; +>>> if (!m) return o; +>>> var i = m.call(o), r, ar = [], e; +>>> try { +>>> while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); +>>> } +>>> catch (error) { e = { error: error }; } +>>> finally { +>>> try { +>>> if (r && !r.done && (m = i["return"])) m.call(i); +>>> } +>>> finally { if (e) throw e.error; } +>>> } +>>> return ar; +>>>}; +>>>try { +>>> for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) { +1 >^^^^ +2 > ^^^ +3 > ^ +4 > ^ +5 > ^^^^ +6 > ^^^^^ +7 > ^^^^^^^^^ +8 > ^ +9 > ^ +10> ^^ +11> ^ +12> ^ +13> ^ +14> ^^^^^^^^^^^^^^^^ +15> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > +2 > for +3 > +4 > (let [a = 0, b = 1] of +5 > +6 > +7 > +8 > [ +9 > 2 +10> , +11> 3 +12> ] +13> +14> +1 >Emitted(28, 5) Source(1, 1) + SourceIndex(0) +2 >Emitted(28, 8) Source(1, 4) + SourceIndex(0) +3 >Emitted(28, 9) Source(1, 5) + SourceIndex(0) +4 >Emitted(28, 10) Source(1, 28) + SourceIndex(0) +5 >Emitted(28, 14) Source(1, 28) + SourceIndex(0) +6 >Emitted(28, 19) Source(1, 28) + SourceIndex(0) +7 >Emitted(28, 28) Source(1, 28) + SourceIndex(0) +8 >Emitted(28, 29) Source(1, 29) + SourceIndex(0) +9 >Emitted(28, 30) Source(1, 30) + SourceIndex(0) +10>Emitted(28, 32) Source(1, 32) + SourceIndex(0) +11>Emitted(28, 33) Source(1, 33) + SourceIndex(0) +12>Emitted(28, 34) Source(1, 34) + SourceIndex(0) +13>Emitted(28, 35) Source(1, 34) + SourceIndex(0) +14>Emitted(28, 51) Source(1, 34) + SourceIndex(0) +--- +>>> var _c = __read(_b.value, 2), _d = _c[0], a = _d === void 0 ? 0 : _d, _e = _c[1], b = _e === void 0 ? 1 : _e; +1->^^^^^^^^ +2 > ^^^^ +3 > ^^^^^^^^^^^^^^^^^^^^^^^^ +4 > ^^ +5 > ^^^^^^^^^^ +6 > ^^ +7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ +8 > ^^ +9 > ^^^^^^^^^^ +10> ^^ +11> ^^^^^^^^^^^^^^^^^^^^^^^^^^ +1-> +2 > +3 > [a = 0, b = 1] +4 > +5 > a = 0 +6 > +7 > a = 0 +8 > , +9 > b = 1 +10> +11> b = 1 +1->Emitted(29, 9) Source(1, 10) + SourceIndex(0) +2 >Emitted(29, 13) Source(1, 10) + SourceIndex(0) +3 >Emitted(29, 37) Source(1, 24) + SourceIndex(0) +4 >Emitted(29, 39) Source(1, 11) + SourceIndex(0) +5 >Emitted(29, 49) Source(1, 16) + SourceIndex(0) +6 >Emitted(29, 51) Source(1, 11) + SourceIndex(0) +7 >Emitted(29, 77) Source(1, 16) + SourceIndex(0) +8 >Emitted(29, 79) Source(1, 18) + SourceIndex(0) +9 >Emitted(29, 89) Source(1, 23) + SourceIndex(0) +10>Emitted(29, 91) Source(1, 18) + SourceIndex(0) +11>Emitted(29, 117) Source(1, 23) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 >] of [2, 3]) { + > +2 > a +3 > ; +1 >Emitted(30, 9) Source(2, 5) + SourceIndex(0) +2 >Emitted(30, 10) Source(2, 6) + SourceIndex(0) +3 >Emitted(30, 11) Source(2, 7) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(31, 9) Source(3, 5) + SourceIndex(0) +2 >Emitted(31, 10) Source(3, 6) + SourceIndex(0) +3 >Emitted(31, 11) Source(3, 7) + SourceIndex(0) +--- +>>> } +1 >^^^^^ +1 > + >} +1 >Emitted(32, 6) Source(4, 2) + SourceIndex(0) +--- +>>>} +>>>catch (e_1_1) { e_1 = { error: e_1_1 }; } +>>>finally { +>>> try { +>>> if (_b && !_b.done && (_f = _a["return"])) _f.call(_a); +>>> } +>>> finally { if (e_1) throw e_1.error; } +>>>} +>>>var e_1, _f; +>>>//# sourceMappingURL=ES5For-of36.js.map \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.js b/tests/baselines/reference/FunctionDeclaration10_es6.js index 6ac2ec8d19436..aca7c00e58c0a 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.js +++ b/tests/baselines/reference/FunctionDeclaration10_es6.js @@ -3,9 +3,7 @@ function * foo(a = yield => yield) { } //// [FunctionDeclaration10_es6.js] -function* foo(a) { - if (a === void 0) { a = yield; } -} +function* foo(a = yield) { } yield; { } diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt deleted file mode 100644 index 4db3842e91d9d..0000000000000 --- a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt +++ /dev/null @@ -1,8 +0,0 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts (1 errors) ==== - function * yield() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.symbols b/tests/baselines/reference/FunctionDeclaration11_es6.symbols new file mode 100644 index 0000000000000..a51b763e4bfd2 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration11_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts === +function * yield() { +>yield : Symbol(yield, Decl(FunctionDeclaration11_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.types b/tests/baselines/reference/FunctionDeclaration11_es6.types new file mode 100644 index 0000000000000..0a312c2661cf2 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration11_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts === +function * yield() { +>yield : () => IterableIterator +} diff --git a/tests/baselines/reference/FunctionDeclaration12_es6.js b/tests/baselines/reference/FunctionDeclaration12_es6.js index 87ea08215fe9c..5d55d3231b009 100644 --- a/tests/baselines/reference/FunctionDeclaration12_es6.js +++ b/tests/baselines/reference/FunctionDeclaration12_es6.js @@ -2,4 +2,4 @@ var v = function * yield() { } //// [FunctionDeclaration12_es6.js] -var v = function* () { }, yield = function () { }; +var v = function* () { }, yield = () => { }; diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt index fa67544661730..1f921475fd330 100644 --- a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'yield'. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (1 errors) ==== function * foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. // Legal to use 'yield' in a type context. var v: yield; ~~~~~ diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt deleted file mode 100644 index d3dab52192659..0000000000000 --- a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt +++ /dev/null @@ -1,8 +0,0 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts (1 errors) ==== - function * foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.symbols b/tests/baselines/reference/FunctionDeclaration1_es6.symbols new file mode 100644 index 0000000000000..7683664cb93f8 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration1_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts === +function * foo() { +>foo : Symbol(foo, Decl(FunctionDeclaration1_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.types b/tests/baselines/reference/FunctionDeclaration1_es6.types new file mode 100644 index 0000000000000..548b1eb98d6f3 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration1_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts === +function * foo() { +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/FunctionDeclaration3_es6.js b/tests/baselines/reference/FunctionDeclaration3_es6.js index e1df936dd21fe..eebce92f5b994 100644 --- a/tests/baselines/reference/FunctionDeclaration3_es6.js +++ b/tests/baselines/reference/FunctionDeclaration3_es6.js @@ -3,6 +3,5 @@ function f(yield = yield) { } //// [FunctionDeclaration3_es6.js] -function f(yield) { - if (yield === void 0) { yield = yield; } +function f(yield = yield) { } diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt index 60798f7dbd68a..04806c7aae9c4 100644 --- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (1 errors) ==== function*foo(a = yield) { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.js b/tests/baselines/reference/FunctionDeclaration6_es6.js index e0b871a9172e1..bc8c3b030aee9 100644 --- a/tests/baselines/reference/FunctionDeclaration6_es6.js +++ b/tests/baselines/reference/FunctionDeclaration6_es6.js @@ -3,6 +3,5 @@ function*foo(a = yield) { } //// [FunctionDeclaration6_es6.js] -function* foo(a) { - if (a === void 0) { a = yield; } +function* foo(a = yield) { } diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt index 3c1b950bea5a9..e0273c3bb44a0 100644 --- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt @@ -1,16 +1,10 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (1 errors) ==== function*bar() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. // 'yield' here is an identifier, and not a yield expression. function*foo(a = yield) { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.js b/tests/baselines/reference/FunctionDeclaration7_es6.js index 49b43e2a2db9f..18256461aeb53 100644 --- a/tests/baselines/reference/FunctionDeclaration7_es6.js +++ b/tests/baselines/reference/FunctionDeclaration7_es6.js @@ -8,7 +8,6 @@ function*bar() { //// [FunctionDeclaration7_es6.js] function* bar() { // 'yield' here is an identifier, and not a yield expression. - function* foo(a) { - if (a === void 0) { a = yield; } + function* foo(a = yield) { } } diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt deleted file mode 100644 index a2d2121d7fa51..0000000000000 --- a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ==== - function * foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - var v = { [yield]: foo } - } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.js b/tests/baselines/reference/FunctionDeclaration9_es6.js index 720e276ccbacf..b5be11778ac80 100644 --- a/tests/baselines/reference/FunctionDeclaration9_es6.js +++ b/tests/baselines/reference/FunctionDeclaration9_es6.js @@ -5,6 +5,5 @@ function * foo() { //// [FunctionDeclaration9_es6.js] function* foo() { - var v = (_a = {}, _a[yield] = foo, _a); - var _a; + var v = { [yield]: foo }; } diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.symbols b/tests/baselines/reference/FunctionDeclaration9_es6.symbols new file mode 100644 index 0000000000000..0797c51331c66 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration9_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts === +function * foo() { +>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0)) + + var v = { [yield]: foo } +>v : Symbol(v, Decl(FunctionDeclaration9_es6.ts, 1, 5)) +>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.types b/tests/baselines/reference/FunctionDeclaration9_es6.types new file mode 100644 index 0000000000000..182b90b3f7a18 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration9_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts === +function * foo() { +>foo : () => IterableIterator + + var v = { [yield]: foo } +>v : { [x: number]: () => IterableIterator; } +>{ [yield]: foo } : { [x: number]: () => IterableIterator; } +>yield : any +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/FunctionExpression1_es6.errors.txt b/tests/baselines/reference/FunctionExpression1_es6.errors.txt deleted file mode 100644 index 9c1f798c5adcc..0000000000000 --- a/tests/baselines/reference/FunctionExpression1_es6.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts (1 errors) ==== - var v = function * () { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. \ No newline at end of file diff --git a/tests/baselines/reference/FunctionExpression1_es6.symbols b/tests/baselines/reference/FunctionExpression1_es6.symbols new file mode 100644 index 0000000000000..4e1ed33ea1cfb --- /dev/null +++ b/tests/baselines/reference/FunctionExpression1_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts === +var v = function * () { } +>v : Symbol(v, Decl(FunctionExpression1_es6.ts, 0, 3)) + diff --git a/tests/baselines/reference/FunctionExpression1_es6.types b/tests/baselines/reference/FunctionExpression1_es6.types new file mode 100644 index 0000000000000..1bba41f11f2e7 --- /dev/null +++ b/tests/baselines/reference/FunctionExpression1_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts === +var v = function * () { } +>v : () => IterableIterator +>function * () { } : () => IterableIterator + diff --git a/tests/baselines/reference/FunctionExpression2_es6.errors.txt b/tests/baselines/reference/FunctionExpression2_es6.errors.txt deleted file mode 100644 index 9248962e620f7..0000000000000 --- a/tests/baselines/reference/FunctionExpression2_es6.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts (1 errors) ==== - var v = function * foo() { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. \ No newline at end of file diff --git a/tests/baselines/reference/FunctionExpression2_es6.symbols b/tests/baselines/reference/FunctionExpression2_es6.symbols new file mode 100644 index 0000000000000..1fc8c3c10d64a --- /dev/null +++ b/tests/baselines/reference/FunctionExpression2_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts === +var v = function * foo() { } +>v : Symbol(v, Decl(FunctionExpression2_es6.ts, 0, 3)) +>foo : Symbol(foo, Decl(FunctionExpression2_es6.ts, 0, 7)) + diff --git a/tests/baselines/reference/FunctionExpression2_es6.types b/tests/baselines/reference/FunctionExpression2_es6.types new file mode 100644 index 0000000000000..7a421dd1abfa4 --- /dev/null +++ b/tests/baselines/reference/FunctionExpression2_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts === +var v = function * foo() { } +>v : () => IterableIterator +>function * foo() { } : () => IterableIterator +>foo : () => IterableIterator + diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt deleted file mode 100644 index fd463eed02dc8..0000000000000 --- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts (1 errors) ==== - var v = { *foo() { } } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. \ No newline at end of file diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.js b/tests/baselines/reference/FunctionPropertyAssignments1_es6.js index 5975745391aab..be89637c5ea1d 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.js +++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.js @@ -2,4 +2,4 @@ var v = { *foo() { } } //// [FunctionPropertyAssignments1_es6.js] -var v = { foo: function* () { } }; +var v = { *foo() { } }; diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols new file mode 100644 index 0000000000000..79aee0f470088 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts === +var v = { *foo() { } } +>v : Symbol(v, Decl(FunctionPropertyAssignments1_es6.ts, 0, 3)) +>foo : Symbol(foo, Decl(FunctionPropertyAssignments1_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.types b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types new file mode 100644 index 0000000000000..90b8615003e82 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts === +var v = { *foo() { } } +>v : { foo(): IterableIterator; } +>{ *foo() { } } : { foo(): IterableIterator; } +>foo : () => IterableIterator + diff --git a/tests/baselines/reference/FunctionPropertyAssignments2_es6.js b/tests/baselines/reference/FunctionPropertyAssignments2_es6.js index b055960b6a81e..b0f66e94c78e1 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments2_es6.js +++ b/tests/baselines/reference/FunctionPropertyAssignments2_es6.js @@ -2,4 +2,4 @@ var v = { *() { } } //// [FunctionPropertyAssignments2_es6.js] -var v = { : function* () { } }; +var v = { *() { } }; diff --git a/tests/baselines/reference/FunctionPropertyAssignments3_es6.js b/tests/baselines/reference/FunctionPropertyAssignments3_es6.js index 9642c28529d87..f13810af3ca34 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments3_es6.js +++ b/tests/baselines/reference/FunctionPropertyAssignments3_es6.js @@ -2,4 +2,4 @@ var v = { *{ } } //// [FunctionPropertyAssignments3_es6.js] -var v = { : function* () { } }; +var v = { *() { } }; diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt index 35185fdb7c642..143b764c08c85 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt +++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt @@ -1,10 +1,7 @@ -tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'. -==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (1 errors) ==== var v = { *[foo()]() { } } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. ~~~ !!! error TS2304: Cannot find name 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js index ba25922b67046..027dc6fb41ec8 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js +++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js @@ -2,5 +2,4 @@ var v = { *[foo()]() { } } //// [FunctionPropertyAssignments5_es6.js] -var v = (_a = {}, _a[foo()] = function* () { }, _a); -var _a; +var v = { *[foo()]() { } }; diff --git a/tests/baselines/reference/FunctionPropertyAssignments6_es6.js b/tests/baselines/reference/FunctionPropertyAssignments6_es6.js index edcd227f7b990..e3f7b7e6332f4 100644 --- a/tests/baselines/reference/FunctionPropertyAssignments6_es6.js +++ b/tests/baselines/reference/FunctionPropertyAssignments6_es6.js @@ -2,4 +2,4 @@ var v = { *() { } } //// [FunctionPropertyAssignments6_es6.js] -var v = { : function* () { } }; +var v = { *() { } }; diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt deleted file mode 100644 index 25cb4ba4240e2..0000000000000 --- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts (1 errors) ==== - class C { - *foo() { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - } \ No newline at end of file diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.js b/tests/baselines/reference/MemberFunctionDeclaration1_es6.js index ec37b3370b03b..3eec7c188cd60 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.js @@ -4,9 +4,6 @@ class C { } //// [MemberFunctionDeclaration1_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function* () { }; - return C; -}()); +class C { + *foo() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols new file mode 100644 index 0000000000000..a1862ea9209d4 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration1_es6.ts, 0, 0)) + + *foo() { } +>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration1_es6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.types b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types new file mode 100644 index 0000000000000..89eec59bb1c15 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts === +class C { +>C : C + + *foo() { } +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt deleted file mode 100644 index 8277d6f1f6739..0000000000000 --- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts (1 errors) ==== - class C { - public * foo() { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - } \ No newline at end of file diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.js b/tests/baselines/reference/MemberFunctionDeclaration2_es6.js index 54550ef72e76d..9dd6bbfb9f9b3 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.js @@ -4,9 +4,6 @@ class C { } //// [MemberFunctionDeclaration2_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function* () { }; - return C; -}()); +class C { + *foo() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols new file mode 100644 index 0000000000000..ac380db0268d3 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration2_es6.ts, 0, 0)) + + public * foo() { } +>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration2_es6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.types b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types new file mode 100644 index 0000000000000..bfc83ccfd2794 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts === +class C { +>C : C + + public * foo() { } +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt index 3fd821bafdfc8..fdfe7425320c1 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt +++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'. -==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (1 errors) ==== class C { *[foo]() { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. ~~~ !!! error TS2304: Cannot find name 'foo'. } \ No newline at end of file diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.js b/tests/baselines/reference/MemberFunctionDeclaration3_es6.js index 07d9a021fcd51..0cfc1732c9975 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.js @@ -4,9 +4,6 @@ class C { } //// [MemberFunctionDeclaration3_es6.js] -var C = (function () { - function C() { - } - C.prototype[foo] = function* () { }; - return C; -}()); +class C { + *[foo]() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration4_es6.js b/tests/baselines/reference/MemberFunctionDeclaration4_es6.js index f791d4a1156a0..73b8f395a929b 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration4_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration4_es6.js @@ -4,9 +4,6 @@ class C { } //// [MemberFunctionDeclaration4_es6.js] -var C = (function () { - function C() { - } - C.prototype. = function* () { }; - return C; -}()); +class C { + *() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration5_es6.js b/tests/baselines/reference/MemberFunctionDeclaration5_es6.js index 2303c5e0f62ed..bbba43eae05a3 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration5_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration5_es6.js @@ -4,8 +4,5 @@ class C { } //// [MemberFunctionDeclaration5_es6.js] -var C = (function () { - function C() { - } - return C; -}()); +class C { +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration6_es6.js b/tests/baselines/reference/MemberFunctionDeclaration6_es6.js index b2a753d7ce068..370697051e6b5 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration6_es6.js @@ -4,8 +4,5 @@ class C { } //// [MemberFunctionDeclaration6_es6.js] -var C = (function () { - function C() { - } - return C; -}()); +class C { +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt deleted file mode 100644 index cd4c49bdd6da1..0000000000000 --- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts (1 errors) ==== - class C { - *foo() { } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - } \ No newline at end of file diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.js b/tests/baselines/reference/MemberFunctionDeclaration7_es6.js index 8e19f0db3331a..78bf55457f74c 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.js @@ -4,9 +4,6 @@ class C { } //// [MemberFunctionDeclaration7_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function* () { }; - return C; -}()); +class C { + *foo() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols new file mode 100644 index 0000000000000..fa07b61e4a660 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration7_es6.ts, 0, 0)) + + *foo() { } +>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration7_es6.ts, 0, 9)) +>T : Symbol(T, Decl(MemberFunctionDeclaration7_es6.ts, 1, 8)) +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.types b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types new file mode 100644 index 0000000000000..b5e65110c68f2 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts === +class C { +>C : C + + *foo() { } +>foo : () => IterableIterator +>T : T +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt index b21af664a69fa..94198b36c9033 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt +++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt @@ -18,7 +18,7 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration !!! error TS1109: Expression expected. ~~~ !!! error TS2304: Cannot find name 'bar'. - return bar; + return bar; ~~~ !!! error TS2304: Cannot find name 'bar'. } diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.js b/tests/baselines/reference/MemberFunctionDeclaration8_es6.js index 8000a2d5c420f..853310e5a3efe 100644 --- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.js +++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.js @@ -3,20 +3,17 @@ class C { foo() { // Make sure we don't think of *bar as the start of a generator method. if (a) # * bar; - return bar; + return bar; } } //// [MemberFunctionDeclaration8_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function () { +class C { + foo() { // Make sure we don't think of *bar as the start of a generator method. if (a) ; * bar; return bar; - }; - return C; -}()); + } +} diff --git a/tests/baselines/reference/YieldExpression10_es6.errors.txt b/tests/baselines/reference/YieldExpression10_es6.errors.txt index 7bf534e418861..9e48fefc10aab 100644 --- a/tests/baselines/reference/YieldExpression10_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression10_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,11): error TS2304: Cannot find name 'foo'. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (1 errors) ==== var v = { * foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. yield(foo); ~~~ !!! error TS2304: Cannot find name 'foo'. diff --git a/tests/baselines/reference/YieldExpression10_es6.js b/tests/baselines/reference/YieldExpression10_es6.js index e1dd44b676b30..f32dd1decf70d 100644 --- a/tests/baselines/reference/YieldExpression10_es6.js +++ b/tests/baselines/reference/YieldExpression10_es6.js @@ -6,7 +6,7 @@ var v = { * foo() { //// [YieldExpression10_es6.js] -var v = { foo: function* () { +var v = { *foo() { yield (foo); } }; diff --git a/tests/baselines/reference/YieldExpression11_es6.errors.txt b/tests/baselines/reference/YieldExpression11_es6.errors.txt index f5d3458520f25..223389e4e3945 100644 --- a/tests/baselines/reference/YieldExpression11_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression11_es6.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'? -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (1 errors) ==== class C { *foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. yield(foo); ~~~ !!! error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'? diff --git a/tests/baselines/reference/YieldExpression11_es6.js b/tests/baselines/reference/YieldExpression11_es6.js index fb4f83c7197ad..46adf67363453 100644 --- a/tests/baselines/reference/YieldExpression11_es6.js +++ b/tests/baselines/reference/YieldExpression11_es6.js @@ -6,11 +6,8 @@ class C { } //// [YieldExpression11_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function* () { +class C { + *foo() { yield (foo); - }; - return C; -}()); + } +} diff --git a/tests/baselines/reference/YieldExpression12_es6.js b/tests/baselines/reference/YieldExpression12_es6.js index 7211d41cb86dc..d0ff7e9d6b86e 100644 --- a/tests/baselines/reference/YieldExpression12_es6.js +++ b/tests/baselines/reference/YieldExpression12_es6.js @@ -6,9 +6,8 @@ class C { } //// [YieldExpression12_es6.js] -var C = (function () { - function C() { +class C { + constructor() { yield foo; } - return C; -}()); +} diff --git a/tests/baselines/reference/YieldExpression13_es6.errors.txt b/tests/baselines/reference/YieldExpression13_es6.errors.txt deleted file mode 100644 index 9908844888696..0000000000000 --- a/tests/baselines/reference/YieldExpression13_es6.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (1 errors) ==== - function* foo() { yield } - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression13_es6.symbols b/tests/baselines/reference/YieldExpression13_es6.symbols new file mode 100644 index 0000000000000..f2e1b100c9d20 --- /dev/null +++ b/tests/baselines/reference/YieldExpression13_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts === +function* foo() { yield } +>foo : Symbol(foo, Decl(YieldExpression13_es6.ts, 0, 0)) + diff --git a/tests/baselines/reference/YieldExpression13_es6.types b/tests/baselines/reference/YieldExpression13_es6.types new file mode 100644 index 0000000000000..011ac1e09e8fe --- /dev/null +++ b/tests/baselines/reference/YieldExpression13_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts === +function* foo() { yield } +>foo : () => IterableIterator +>yield : any + diff --git a/tests/baselines/reference/YieldExpression14_es6.js b/tests/baselines/reference/YieldExpression14_es6.js index e8c33c2085e15..e25a29e606f04 100644 --- a/tests/baselines/reference/YieldExpression14_es6.js +++ b/tests/baselines/reference/YieldExpression14_es6.js @@ -6,11 +6,8 @@ class C { } //// [YieldExpression14_es6.js] -var C = (function () { - function C() { - } - C.prototype.foo = function () { +class C { + foo() { yield foo; - }; - return C; -}()); + } +} diff --git a/tests/baselines/reference/YieldExpression15_es6.js b/tests/baselines/reference/YieldExpression15_es6.js index 1e4431d6168ba..d03699922f600 100644 --- a/tests/baselines/reference/YieldExpression15_es6.js +++ b/tests/baselines/reference/YieldExpression15_es6.js @@ -4,6 +4,6 @@ var v = () => { } //// [YieldExpression15_es6.js] -var v = function () { +var v = () => { yield foo; }; diff --git a/tests/baselines/reference/YieldExpression16_es6.errors.txt b/tests/baselines/reference/YieldExpression16_es6.errors.txt index 0645f5d818ae1..94e082f4c2760 100644 --- a/tests/baselines/reference/YieldExpression16_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (1 errors) ==== function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. function bar() { yield foo; ~~~~~ diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt index f987517371f87..540b1a889f02c 100644 --- a/tests/baselines/reference/YieldExpression17_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt @@ -1,13 +1,10 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (3 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (2 errors) ==== var v = { get foo() { yield foo; } } ~~~ -!!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. - ~~~ !!! error TS2378: A 'get' accessor must return a value. ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression19_es6.errors.txt b/tests/baselines/reference/YieldExpression19_es6.errors.txt deleted file mode 100644 index f07cfc1db7833..0000000000000 --- a/tests/baselines/reference/YieldExpression19_es6.errors.txt +++ /dev/null @@ -1,16 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. -tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (2 errors) ==== - function*foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - function bar() { - function* quux() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield(foo); - } - } - } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression19_es6.symbols b/tests/baselines/reference/YieldExpression19_es6.symbols new file mode 100644 index 0000000000000..609102001c453 --- /dev/null +++ b/tests/baselines/reference/YieldExpression19_es6.symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts === +function*foo() { +>foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0)) + + function bar() { +>bar : Symbol(bar, Decl(YieldExpression19_es6.ts, 0, 16)) + + function* quux() { +>quux : Symbol(quux, Decl(YieldExpression19_es6.ts, 1, 18)) + + yield(foo); +>foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0)) + } + } +} diff --git a/tests/baselines/reference/YieldExpression19_es6.types b/tests/baselines/reference/YieldExpression19_es6.types new file mode 100644 index 0000000000000..f57b175d53c92 --- /dev/null +++ b/tests/baselines/reference/YieldExpression19_es6.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts === +function*foo() { +>foo : () => IterableIterator + + function bar() { +>bar : () => void + + function* quux() { +>quux : () => IterableIterator<() => IterableIterator> + + yield(foo); +>yield(foo) : any +>(foo) : () => IterableIterator +>foo : () => IterableIterator + } + } +} diff --git a/tests/baselines/reference/YieldExpression3_es6.errors.txt b/tests/baselines/reference/YieldExpression3_es6.errors.txt deleted file mode 100644 index 9f07c13184e34..0000000000000 --- a/tests/baselines/reference/YieldExpression3_es6.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (1 errors) ==== - function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield - yield - } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression3_es6.symbols b/tests/baselines/reference/YieldExpression3_es6.symbols new file mode 100644 index 0000000000000..4ab5b42688f83 --- /dev/null +++ b/tests/baselines/reference/YieldExpression3_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression3_es6.ts, 0, 0)) + + yield + yield +} diff --git a/tests/baselines/reference/YieldExpression3_es6.types b/tests/baselines/reference/YieldExpression3_es6.types new file mode 100644 index 0000000000000..9e2f810d91129 --- /dev/null +++ b/tests/baselines/reference/YieldExpression3_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts === +function* foo() { +>foo : () => IterableIterator + + yield +>yield : any + + yield +>yield : any +} diff --git a/tests/baselines/reference/YieldExpression4_es6.errors.txt b/tests/baselines/reference/YieldExpression4_es6.errors.txt deleted file mode 100644 index 6c9a5796ee836..0000000000000 --- a/tests/baselines/reference/YieldExpression4_es6.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (1 errors) ==== - function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield; - yield; - } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression4_es6.symbols b/tests/baselines/reference/YieldExpression4_es6.symbols new file mode 100644 index 0000000000000..7954fb705e60f --- /dev/null +++ b/tests/baselines/reference/YieldExpression4_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression4_es6.ts, 0, 0)) + + yield; + yield; +} diff --git a/tests/baselines/reference/YieldExpression4_es6.types b/tests/baselines/reference/YieldExpression4_es6.types new file mode 100644 index 0000000000000..929bef38edd1d --- /dev/null +++ b/tests/baselines/reference/YieldExpression4_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts === +function* foo() { +>foo : () => IterableIterator + + yield; +>yield : any + + yield; +>yield : any +} diff --git a/tests/baselines/reference/YieldExpression6_es6.errors.txt b/tests/baselines/reference/YieldExpression6_es6.errors.txt index f2fc90b81b41d..b8c0967864cd6 100644 --- a/tests/baselines/reference/YieldExpression6_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression6_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,9): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (1 errors) ==== function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. yield*foo ~~~ !!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. diff --git a/tests/baselines/reference/YieldExpression7_es6.errors.txt b/tests/baselines/reference/YieldExpression7_es6.errors.txt deleted file mode 100644 index f929dff0a2a57..0000000000000 --- a/tests/baselines/reference/YieldExpression7_es6.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (1 errors) ==== - function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield foo - } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression7_es6.symbols b/tests/baselines/reference/YieldExpression7_es6.symbols new file mode 100644 index 0000000000000..53737c94be936 --- /dev/null +++ b/tests/baselines/reference/YieldExpression7_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression7_es6.ts, 0, 0)) + + yield foo +>foo : Symbol(foo, Decl(YieldExpression7_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/YieldExpression7_es6.types b/tests/baselines/reference/YieldExpression7_es6.types new file mode 100644 index 0000000000000..44dcc196c3bdc --- /dev/null +++ b/tests/baselines/reference/YieldExpression7_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts === +function* foo() { +>foo : () => IterableIterator + + yield foo +>yield foo : any +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/YieldExpression8_es6.errors.txt b/tests/baselines/reference/YieldExpression8_es6.errors.txt index aef1fbc122d6e..f4dd30b1a1947 100644 --- a/tests/baselines/reference/YieldExpression8_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression8_es6.errors.txt @@ -1,13 +1,10 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(1,1): error TS2304: Cannot find name 'yield'. -tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (1 errors) ==== yield(foo); ~~~~~ !!! error TS2304: Cannot find name 'yield'. function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. yield(foo); } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression9_es6.errors.txt b/tests/baselines/reference/YieldExpression9_es6.errors.txt index 2ad925a90a064..1241e615f798e 100644 --- a/tests/baselines/reference/YieldExpression9_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression9_es6.errors.txt @@ -1,11 +1,8 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(2,9): error TS2304: Cannot find name 'foo'. -==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (1 errors) ==== var v = function*() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. yield(foo); ~~~ !!! error TS2304: Cannot find name 'foo'. diff --git a/tests/baselines/reference/YieldStarExpression4_es6.errors.txt b/tests/baselines/reference/YieldStarExpression4_es6.errors.txt deleted file mode 100644 index c58844a92887b..0000000000000 --- a/tests/baselines/reference/YieldStarExpression4_es6.errors.txt +++ /dev/null @@ -1,12 +0,0 @@ -tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. -tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(2,13): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. - - -==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts (2 errors) ==== - function *g() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield * []; - ~~ -!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. - } \ No newline at end of file diff --git a/tests/baselines/reference/YieldStarExpression4_es6.symbols b/tests/baselines/reference/YieldStarExpression4_es6.symbols new file mode 100644 index 0000000000000..c23e2ac8895ce --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression4_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts === +function *g() { +>g : Symbol(g, Decl(YieldStarExpression4_es6.ts, 0, 0)) + + yield * []; +} diff --git a/tests/baselines/reference/YieldStarExpression4_es6.types b/tests/baselines/reference/YieldStarExpression4_es6.types new file mode 100644 index 0000000000000..1d72e6dc50651 --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression4_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts === +function *g() { +>g : () => IterableIterator + + yield * []; +>yield * [] : any +>[] : undefined[] +} diff --git a/tests/baselines/reference/arrayLiteralSpreadES5iterable.js b/tests/baselines/reference/arrayLiteralSpreadES5iterable.js new file mode 100644 index 0000000000000..d71f49242dd58 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralSpreadES5iterable.js @@ -0,0 +1,66 @@ +//// [arrayLiteralSpreadES5iterable.ts] +function f0() { + var a = [1, 2, 3]; + var a1 = [...a]; + var a2 = [1, ...a]; + var a3 = [1, 2, ...a]; + var a4 = [...a, 1]; + var a5 = [...a, 1, 2]; + var a6 = [1, 2, ...a, 1, 2]; + var a7 = [1, ...a, 2, ...a]; + var a8 = [...a, ...a, ...a]; +} + +function f1() { + var a = [1, 2, 3]; + var b = ["hello", ...a, true]; + var b: (string | number | boolean)[]; +} + +function f2() { + var a = [...[...[...[...[...[]]]]]]; + var b = [...[...[...[...[...[5]]]]]]; +} + + +//// [arrayLiteralSpreadES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +function f0() { + var a = [1, 2, 3]; + var a1 = __spread(a); + var a2 = __spread([1], a); + var a3 = __spread([1, 2], a); + var a4 = __spread(a, [1]); + var a5 = __spread(a, [1, 2]); + var a6 = __spread([1, 2], a, [1, 2]); + var a7 = __spread([1], a, [2], a); + var a8 = __spread(a, a, a); +} +function f1() { + var a = [1, 2, 3]; + var b = __spread(["hello"], a, [true]); + var b; +} +function f2() { + var a = __spread([]); + var b = __spread([5]); +} diff --git a/tests/baselines/reference/arrayLiteralSpreadES5iterable.symbols b/tests/baselines/reference/arrayLiteralSpreadES5iterable.symbols new file mode 100644 index 0000000000000..e31cc74e013f4 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralSpreadES5iterable.symbols @@ -0,0 +1,67 @@ +=== tests/cases/conformance/es6/spread/arrayLiteralSpreadES5iterable.ts === +function f0() { +>f0 : Symbol(f0, Decl(arrayLiteralSpreadES5iterable.ts, 0, 0)) + + var a = [1, 2, 3]; +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a1 = [...a]; +>a1 : Symbol(a1, Decl(arrayLiteralSpreadES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a2 = [1, ...a]; +>a2 : Symbol(a2, Decl(arrayLiteralSpreadES5iterable.ts, 3, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a3 = [1, 2, ...a]; +>a3 : Symbol(a3, Decl(arrayLiteralSpreadES5iterable.ts, 4, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a4 = [...a, 1]; +>a4 : Symbol(a4, Decl(arrayLiteralSpreadES5iterable.ts, 5, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a5 = [...a, 1, 2]; +>a5 : Symbol(a5, Decl(arrayLiteralSpreadES5iterable.ts, 6, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a6 = [1, 2, ...a, 1, 2]; +>a6 : Symbol(a6, Decl(arrayLiteralSpreadES5iterable.ts, 7, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a7 = [1, ...a, 2, ...a]; +>a7 : Symbol(a7, Decl(arrayLiteralSpreadES5iterable.ts, 8, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) + + var a8 = [...a, ...a, ...a]; +>a8 : Symbol(a8, Decl(arrayLiteralSpreadES5iterable.ts, 9, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 1, 7)) +} + +function f1() { +>f1 : Symbol(f1, Decl(arrayLiteralSpreadES5iterable.ts, 10, 1)) + + var a = [1, 2, 3]; +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 13, 7)) + + var b = ["hello", ...a, true]; +>b : Symbol(b, Decl(arrayLiteralSpreadES5iterable.ts, 14, 7), Decl(arrayLiteralSpreadES5iterable.ts, 15, 7)) +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 13, 7)) + + var b: (string | number | boolean)[]; +>b : Symbol(b, Decl(arrayLiteralSpreadES5iterable.ts, 14, 7), Decl(arrayLiteralSpreadES5iterable.ts, 15, 7)) +} + +function f2() { +>f2 : Symbol(f2, Decl(arrayLiteralSpreadES5iterable.ts, 16, 1)) + + var a = [...[...[...[...[...[]]]]]]; +>a : Symbol(a, Decl(arrayLiteralSpreadES5iterable.ts, 19, 7)) + + var b = [...[...[...[...[...[5]]]]]]; +>b : Symbol(b, Decl(arrayLiteralSpreadES5iterable.ts, 20, 7)) +} + diff --git a/tests/baselines/reference/arrayLiteralSpreadES5iterable.types b/tests/baselines/reference/arrayLiteralSpreadES5iterable.types new file mode 100644 index 0000000000000..21c41bb6dcef9 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralSpreadES5iterable.types @@ -0,0 +1,133 @@ +=== tests/cases/conformance/es6/spread/arrayLiteralSpreadES5iterable.ts === +function f0() { +>f0 : () => void + + var a = [1, 2, 3]; +>a : number[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + + var a1 = [...a]; +>a1 : number[] +>[...a] : number[] +>...a : number +>a : number[] + + var a2 = [1, ...a]; +>a2 : number[] +>[1, ...a] : number[] +>1 : 1 +>...a : number +>a : number[] + + var a3 = [1, 2, ...a]; +>a3 : number[] +>[1, 2, ...a] : number[] +>1 : 1 +>2 : 2 +>...a : number +>a : number[] + + var a4 = [...a, 1]; +>a4 : number[] +>[...a, 1] : number[] +>...a : number +>a : number[] +>1 : 1 + + var a5 = [...a, 1, 2]; +>a5 : number[] +>[...a, 1, 2] : number[] +>...a : number +>a : number[] +>1 : 1 +>2 : 2 + + var a6 = [1, 2, ...a, 1, 2]; +>a6 : number[] +>[1, 2, ...a, 1, 2] : number[] +>1 : 1 +>2 : 2 +>...a : number +>a : number[] +>1 : 1 +>2 : 2 + + var a7 = [1, ...a, 2, ...a]; +>a7 : number[] +>[1, ...a, 2, ...a] : number[] +>1 : 1 +>...a : number +>a : number[] +>2 : 2 +>...a : number +>a : number[] + + var a8 = [...a, ...a, ...a]; +>a8 : number[] +>[...a, ...a, ...a] : number[] +>...a : number +>a : number[] +>...a : number +>a : number[] +>...a : number +>a : number[] +} + +function f1() { +>f1 : () => void + + var a = [1, 2, 3]; +>a : number[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + + var b = ["hello", ...a, true]; +>b : (string | number | boolean)[] +>["hello", ...a, true] : (string | number | boolean)[] +>"hello" : "hello" +>...a : number +>a : number[] +>true : true + + var b: (string | number | boolean)[]; +>b : (string | number | boolean)[] +} + +function f2() { +>f2 : () => void + + var a = [...[...[...[...[...[]]]]]]; +>a : any[] +>[...[...[...[...[...[]]]]]] : undefined[] +>...[...[...[...[...[]]]]] : undefined +>[...[...[...[...[]]]]] : undefined[] +>...[...[...[...[]]]] : undefined +>[...[...[...[]]]] : undefined[] +>...[...[...[]]] : undefined +>[...[...[]]] : undefined[] +>...[...[]] : undefined +>[...[]] : undefined[] +>...[] : undefined +>[] : undefined[] + + var b = [...[...[...[...[...[5]]]]]]; +>b : number[] +>[...[...[...[...[...[5]]]]]] : number[] +>...[...[...[...[...[5]]]]] : number +>[...[...[...[...[5]]]]] : number[] +>...[...[...[...[5]]]] : number +>[...[...[...[5]]]] : number[] +>...[...[...[5]]] : number +>[...[...[5]]] : number[] +>...[...[5]] : number +>[...[5]] : number[] +>...[5] : number +>[5] : number[] +>5 : 5 +} + diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js index bd05f90a26e38..335bd8a340ec9 100644 --- a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js @@ -50,8 +50,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.js b/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.js index 6d167a000894a..edceab4cf9645 100644 --- a/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.js +++ b/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.js @@ -58,7 +58,7 @@ function fn1() { _a.label = 1; case 1: if (!(i < 1)) return [3 /*break*/, 4]; - return [5 /*yield**/, _loop_1(i)]; + return [5 /*yield**/, __values(_loop_1(i))]; case 2: _a.sent(); _a.label = 3; @@ -92,7 +92,7 @@ function fn2() { _a.label = 1; case 1: if (!(i < 1)) return [3 /*break*/, 4]; - return [5 /*yield**/, _loop_2(i)]; + return [5 /*yield**/, __values(_loop_2(i))]; case 2: state_1 = _a.sent(); if (state_1 === "break") @@ -128,7 +128,7 @@ function fn3() { _a.label = 1; case 1: if (!(i < 1)) return [3 /*break*/, 4]; - return [5 /*yield**/, _loop_3(i)]; + return [5 /*yield**/, __values(_loop_3(i))]; case 2: _a.sent(); _a.label = 3; @@ -162,7 +162,7 @@ function fn4() { _a.label = 1; case 1: if (!(i < 1)) return [3 /*break*/, 4]; - return [5 /*yield**/, _loop_4(i)]; + return [5 /*yield**/, __values(_loop_4(i))]; case 2: state_2 = _a.sent(); if (typeof state_2 === "object") diff --git a/tests/baselines/reference/asyncAwait_es5.js b/tests/baselines/reference/asyncAwait_es5.js index e4dc62ea1cf99..f49f4472b133d 100644 --- a/tests/baselines/reference/asyncAwait_es5.js +++ b/tests/baselines/reference/asyncAwait_es5.js @@ -49,8 +49,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es5.js b/tests/baselines/reference/asyncFunctionDeclaration12_es5.js index 4123175b22ced..21651a4279606 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration12_es5.js +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es5.js @@ -2,4 +2,8 @@ var v = async function await(): Promise { } //// [asyncFunctionDeclaration12_es5.js] -var v = , await = function () { }; +var v = function () { + return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { + return [2 /*return*/]; + }); }); +}, await = function () { }; diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.js b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js index dae33682ce6ae..9943c3896b63f 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration12_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js @@ -2,4 +2,6 @@ var v = async function await(): Promise { } //// [asyncFunctionDeclaration12_es6.js] -var v = , await = () => { }; +var v = function () { + return __awaiter(this, void 0, void 0, function* () { }); +}, await = () => { }; diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt index a5334d5b9d736..f8029687fb15a 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt @@ -8,8 +8,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1 Types of property 'then' are incompatible. Type '() => void' is not assignable to type '(onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => PromiseLike'. Type 'void' is not assignable to type 'PromiseLike'. -tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(17,16): error TS1059: Return expression in async function does not have a valid callable 'then' member. -tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(23,25): error TS1058: Operand for 'await' does not have a valid callable 'then' member. +tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(17,16): error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. +tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(23,25): error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. ==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts (8 errors) ==== @@ -47,7 +47,7 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1 async function fn12() { return obj; } // valid: Promise<{ then: string; }> async function fn13() { return thenable; } // error ~~~~ -!!! error TS1059: Return expression in async function does not have a valid callable 'then' member. +!!! error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. async function fn14() { await 1; } // valid: Promise async function fn15() { await null; } // valid: Promise async function fn16() { await undefined; } // valid: Promise @@ -55,5 +55,5 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1 async function fn18() { await obj; } // valid: Promise async function fn19() { await thenable; } // error ~~~~~~~~~~~~~~ -!!! error TS1058: Operand for 'await' does not have a valid callable 'then' member. +!!! error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt index e8d3e7d79b1e8..60f57f3dfbffa 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt @@ -3,8 +3,8 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,23): error TS1064: The return type of an async function or method must be the global Promise type. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,23): error TS1064: The return type of an async function or method must be the global Promise type. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,23): error TS1064: The return type of an async function or method must be the global Promise type. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1059: Return expression in async function does not have a valid callable 'then' member. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(23,25): error TS1058: Operand for 'await' does not have a valid callable 'then' member. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(23,25): error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. ==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts (7 errors) ==== @@ -36,7 +36,7 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1 async function fn12() { return obj; } // valid: Promise<{ then: string; }> async function fn13() { return thenable; } // error ~~~~ -!!! error TS1059: Return expression in async function does not have a valid callable 'then' member. +!!! error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. async function fn14() { await 1; } // valid: Promise async function fn15() { await null; } // valid: Promise async function fn16() { await undefined; } // valid: Promise @@ -44,5 +44,5 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1 async function fn18() { await obj; } // valid: Promise async function fn19() { await thenable; } // error ~~~~~~~~~~~~~~ -!!! error TS1058: Operand for 'await' does not have a valid callable 'then' member. +!!! error TS1058: Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member. \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.js b/tests/baselines/reference/asyncFunctionNoReturnType.js index b1c5541656643..6f4a3795118fe 100644 --- a/tests/baselines/reference/asyncFunctionNoReturnType.js +++ b/tests/baselines/reference/asyncFunctionNoReturnType.js @@ -15,8 +15,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/asyncImportedPromise_es5.js b/tests/baselines/reference/asyncImportedPromise_es5.js index 550f0d2357e82..8a6ec4240caf0 100644 --- a/tests/baselines/reference/asyncImportedPromise_es5.js +++ b/tests/baselines/reference/asyncImportedPromise_es5.js @@ -41,8 +41,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/asyncMultiFile_es5.js b/tests/baselines/reference/asyncMultiFile_es5.js index 547135e5c193b..67a3ce258b4b3 100644 --- a/tests/baselines/reference/asyncMultiFile_es5.js +++ b/tests/baselines/reference/asyncMultiFile_es5.js @@ -15,8 +15,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/awaitCallExpression2_es5.js b/tests/baselines/reference/awaitCallExpression2_es5.js index 6b0d6e4b648f7..d9c51e84822d0 100644 --- a/tests/baselines/reference/awaitCallExpression2_es5.js +++ b/tests/baselines/reference/awaitCallExpression2_es5.js @@ -16,15 +16,15 @@ async function func(): Promise { //// [awaitCallExpression2_es5.js] function func() { return __awaiter(this, void 0, void 0, function () { - var b, _a, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var b, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: before(); _a = fn; return [4 /*yield*/, p]; case 1: - b = _a.apply(void 0, [_c.sent(), a, a]); + b = _a.apply(void 0, [_b.sent(), a, a]); after(); return [2 /*return*/]; } diff --git a/tests/baselines/reference/awaitCallExpression6_es5.js b/tests/baselines/reference/awaitCallExpression6_es5.js index acc4261eacbb2..23def82fee72a 100644 --- a/tests/baselines/reference/awaitCallExpression6_es5.js +++ b/tests/baselines/reference/awaitCallExpression6_es5.js @@ -16,15 +16,15 @@ async function func(): Promise { //// [awaitCallExpression6_es5.js] function func() { return __awaiter(this, void 0, void 0, function () { - var b, _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var b, _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: before(); _b = (_a = o).fn; return [4 /*yield*/, p]; case 1: - b = _b.apply(_a, [_d.sent(), a, a]); + b = _b.apply(_a, [_c.sent(), a, a]); after(); return [2 /*return*/]; } diff --git a/tests/baselines/reference/awaitClassExpression_es5.js b/tests/baselines/reference/awaitClassExpression_es5.js index 9cb8ce22f6330..1ef7338fb1287 100644 --- a/tests/baselines/reference/awaitClassExpression_es5.js +++ b/tests/baselines/reference/awaitClassExpression_es5.js @@ -10,9 +10,9 @@ async function func(): Promise { //// [awaitClassExpression_es5.js] function func() { return __awaiter(this, void 0, void 0, function () { - var D, _a, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var D, _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: _a = function (_super) { __extends(D, _super); @@ -23,7 +23,7 @@ function func() { }; return [4 /*yield*/, p]; case 1: - D = (_a.apply(void 0, [(_c.sent())])); + D = (_a.apply(void 0, [(_b.sent())])); return [2 /*return*/]; } }); diff --git a/tests/baselines/reference/castOfAwait.types b/tests/baselines/reference/castOfAwait.types index 805affe49db4b..afe075b67d91a 100644 --- a/tests/baselines/reference/castOfAwait.types +++ b/tests/baselines/reference/castOfAwait.types @@ -18,7 +18,7 @@ async function f() { >0 : 0 await void typeof void await 0; ->await void typeof void await 0 : any +>await void typeof void await 0 : undefined >void typeof void await 0 : undefined > typeof void await 0 : string >typeof void await 0 : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function" diff --git a/tests/baselines/reference/castOfYield.errors.txt b/tests/baselines/reference/castOfYield.errors.txt index abafe67878430..0d40a4dcd987d 100644 --- a/tests/baselines/reference/castOfYield.errors.txt +++ b/tests/baselines/reference/castOfYield.errors.txt @@ -1,6 +1,8 @@ +error TS2318: Cannot find global type 'IterableIterator'. tests/cases/compiler/castOfYield.ts(4,14): error TS1109: Expression expected. +!!! error TS2318: Cannot find global type 'IterableIterator'. ==== tests/cases/compiler/castOfYield.ts (1 errors) ==== function* f() { (yield 0); diff --git a/tests/baselines/reference/castOfYield.js b/tests/baselines/reference/castOfYield.js index 633f780a6a144..9ad9ec52a3140 100644 --- a/tests/baselines/reference/castOfYield.js +++ b/tests/baselines/reference/castOfYield.js @@ -7,9 +7,45 @@ function* f() { //// [castOfYield.js] -function* f() { - (yield 0); - // Unlike await, yield is not allowed to appear in a simple unary expression. - ; - yield 0; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function f() { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, 0]; + case 1: + (_a.sent()); + // Unlike await, yield is not allowed to appear in a simple unary expression. + ; + return [4 /*yield*/, 0]; + case 2: + _a.sent(); + return [2 /*return*/]; + } + }); } diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.errors.txt new file mode 100644 index 0000000000000..6a2647013fb0b --- /dev/null +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.errors.txt @@ -0,0 +1,65 @@ +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES5iterable.ts(43,6): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES5iterable.ts(44,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES5iterable.ts(44,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. + + +==== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES5iterable.ts (3 errors) ==== + /* AssignmentPattern: + * ObjectAssignmentPattern + * ArrayAssignmentPattern + * ArrayAssignmentPattern: + * [Elision AssignmentRestElementopt ] + * [AssignmentElementList] + * [AssignmentElementList, Elision AssignmentRestElementopt ] + * AssignmentElementList: + * Elision AssignmentElement + * AssignmentElementList, Elisionopt AssignmentElement + * AssignmentElement: + * LeftHandSideExpression Initialiseropt + * AssignmentPattern Initialiseropt + * AssignmentRestElement: + * ... LeftHandSideExpression + */ + + // In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left. + // An expression of type S is considered assignable to an assignment target V if one of the following is true + + // V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, + // S is the type Any, or + + var [a0, a1]: any = undefined; + var [a2 = false, a3 = 1]: any = undefined; + + // V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, + // S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E, + // where N is the numeric index of E in the array assignment pattern, or + var [b0, b1, b2] = [2, 3, 4]; + var [b3, b4, b5]: [number, number, string] = [1, 2, "string"]; + + function foo() { + return [1, 2, 3]; + } + + var [b6, b7] = foo(); + var [...b8] = foo(); + + // S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E. + var temp = [1,2,3] + var [c0, c1] = [...temp]; + var [c2] = []; + ~~ +!!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. + var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]] + ~~ +!!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. + ~~ +!!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. + var [[c5], c6]: [[string|number], boolean] = [[1], true]; + var [, c7] = [1, 2, 3]; + var [,,, c8] = [1, 2, 3, 4]; + var [,,, c9] = [1, 2, 3, 4]; + var [,,,...c10] = [1, 2, 3, 4, "hello"]; + var [c11, c12, ...c13] = [1, 2, "string"]; + var [c14, c15, c16] = [1, 2, "string"]; + + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.js b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.js new file mode 100644 index 0000000000000..acb56cfb8adb5 --- /dev/null +++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.js @@ -0,0 +1,120 @@ +//// [destructuringArrayBindingPatternAndAssignment1ES5iterable.ts] +/* AssignmentPattern: + * ObjectAssignmentPattern + * ArrayAssignmentPattern + * ArrayAssignmentPattern: + * [Elision AssignmentRestElementopt ] + * [AssignmentElementList] + * [AssignmentElementList, Elision AssignmentRestElementopt ] + * AssignmentElementList: + * Elision AssignmentElement + * AssignmentElementList, Elisionopt AssignmentElement + * AssignmentElement: + * LeftHandSideExpression Initialiseropt + * AssignmentPattern Initialiseropt + * AssignmentRestElement: + * ... LeftHandSideExpression + */ + +// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left. +// An expression of type S is considered assignable to an assignment target V if one of the following is true + +// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, +// S is the type Any, or + +var [a0, a1]: any = undefined; +var [a2 = false, a3 = 1]: any = undefined; + +// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, +// S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E, +// where N is the numeric index of E in the array assignment pattern, or +var [b0, b1, b2] = [2, 3, 4]; +var [b3, b4, b5]: [number, number, string] = [1, 2, "string"]; + +function foo() { + return [1, 2, 3]; +} + +var [b6, b7] = foo(); +var [...b8] = foo(); + +// S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E. +var temp = [1,2,3] +var [c0, c1] = [...temp]; +var [c2] = []; +var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]] +var [[c5], c6]: [[string|number], boolean] = [[1], true]; +var [, c7] = [1, 2, 3]; +var [,,, c8] = [1, 2, 3, 4]; +var [,,, c9] = [1, 2, 3, 4]; +var [,,,...c10] = [1, 2, 3, 4, "hello"]; +var [c11, c12, ...c13] = [1, 2, "string"]; +var [c14, c15, c16] = [1, 2, "string"]; + + + +//// [destructuringArrayBindingPatternAndAssignment1ES5iterable.js] +/* AssignmentPattern: + * ObjectAssignmentPattern + * ArrayAssignmentPattern + * ArrayAssignmentPattern: + * [Elision AssignmentRestElementopt ] + * [AssignmentElementList] + * [AssignmentElementList, Elision AssignmentRestElementopt ] + * AssignmentElementList: + * Elision AssignmentElement + * AssignmentElementList, Elisionopt AssignmentElement + * AssignmentElement: + * LeftHandSideExpression Initialiseropt + * AssignmentPattern Initialiseropt + * AssignmentRestElement: + * ... LeftHandSideExpression + */ +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left. +// An expression of type S is considered assignable to an assignment target V if one of the following is true +// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, +// S is the type Any, or +var _a = __read(undefined, 2), a0 = _a[0], a1 = _a[1]; +var _b = __read(undefined, 2), _c = _b[0], a2 = _c === void 0 ? false : _c, _d = _b[1], a3 = _d === void 0 ? 1 : _d; +// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V, +// S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E, +// where N is the numeric index of E in the array assignment pattern, or +var _e = __read([2, 3, 4], 3), b0 = _e[0], b1 = _e[1], b2 = _e[2]; +var _f = __read([1, 2, "string"], 3), b3 = _f[0], b4 = _f[1], b5 = _f[2]; +function foo() { + return [1, 2, 3]; +} +var _g = __read(foo(), 2), b6 = _g[0], b7 = _g[1]; +var _h = __read(foo()), b8 = _h.slice(0); +// S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E. +var temp = [1, 2, 3]; +var _j = __read(__spread(temp), 2), c0 = _j[0], c1 = _j[1]; +var _k = __read([], 1), c2 = _k[0]; +var _l = __read([[[]], [[[[]]]]], 2), _m = __read(_l[0], 1), _o = __read(_m[0], 1), c3 = _o[0], _p = __read(_l[1], 1), _q = __read(_p[0], 1), _r = __read(_q[0], 1), _s = __read(_r[0], 1), c4 = _s[0]; +var _t = __read([[1], true], 2), _u = __read(_t[0], 1), c5 = _u[0], c6 = _t[1]; +var _v = __read([1, 2, 3], 2), c7 = _v[1]; +var _w = __read([1, 2, 3, 4], 4), c8 = _w[3]; +var _x = __read([1, 2, 3, 4], 4), c9 = _x[3]; +var _y = __read([1, 2, 3, 4, "hello"]), c10 = _y.slice(3); +var _z = __read([1, 2, "string"]), c11 = _z[0], c12 = _z[1], c13 = _z.slice(2); +var _0 = __read([1, 2, "string"], 3), c14 = _0[0], c15 = _0[1], c16 = _0[2]; diff --git a/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.errors.txt b/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.errors.txt new file mode 100644 index 0000000000000..101a37fc84a9a --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.errors.txt @@ -0,0 +1,106 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5iterable.ts(62,10): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5iterable.ts(63,10): error TS2393: Duplicate function implementation. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration1ES5iterable.ts (2 errors) ==== + // A parameter declaration may specify either an identifier or a binding pattern. + // The identifiers specified in parameter declarations and binding patterns + // in a parameter list must be unique within that parameter list. + + // If the declaration includes a type annotation, the parameter is of that type + function a1([a, b, [[c]]]: [number, number, string[][]]) { } + function a2(o: { x: number, a: number }) { } + function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { }; + function a4({x, a}: { x: number, a: number }) { } + + a1([1, 2, [["world"]]]); + a1([1, 2, [["world"]], 3]); + + // If the declaration includes an initializer expression (which is permitted only + // when the parameter list occurs in conjunction with a function body), + // the parameter type is the widened form (section 3.11) of the type of the initializer expression. + + function b1(z = [undefined, null]) { }; + function b2(z = null, o = { x: 0, y: undefined }) { } + function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { } + + interface F1 { + b5(z, y, [, a, b], {p, m: { q, r}}); + } + + function b6([a, z, y] = [undefined, null, undefined]) { } + function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { } + + b1([1, 2, 3]); // z is widen to the type any[] + b2("string", { x: 200, y: "string" }); + b2("string", { x: 200, y: true }); + b6(["string", 1, 2]); // Shouldn't be an error + b7([["string"], 1, [[true, false]]]); // Shouldn't be an error + + + // If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3) + enum Foo { a } + function c0({z: {x, y: {j}}}) { } + function c1({z} = { z: 10 }) { } + function c2({z = 10}) { } + function c3({b}: { b: number|string} = { b: "hello" }) { } + function c5([a, b, [[c]]]) { } + function c6([a, b, [[c=1]]]) { } + + c0({z : { x: 1, y: { j: "world" } }}); // Implied type is { z: {x: any, y: {j: any}} } + c0({z : { x: "string", y: { j: true } }}); // Implied type is { z: {x: any, y: {j: any}} } + + c1(); // Implied type is {z:number}? + c1({ z: 1 }) // Implied type is {z:number}? + + c2({}); // Implied type is {z?: number} + c2({z:1}); // Implied type is {z?: number} + + c3({ b: 1 }); // Implied type is { b: number|string }. + + c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]] + c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]] + + // A parameter can be marked optional by following its name or binding pattern with a question mark (?) + // or by including an initializer. + + function d0(x?) { } + ~~ +!!! error TS2393: Duplicate function implementation. + function d0(x = 10) { } + ~~ +!!! error TS2393: Duplicate function implementation. + + interface F2 { + d3([a, b, c]?); + d4({x, y, z}?); + e0([a, b, c]); + } + + class C2 implements F2 { + constructor() { } + d3() { } + d4() { } + e0([a, b, c]) { } + } + + class C3 implements F2 { + d3([a, b, c]) { } + d4({x, y, z}) { } + e0([a, b, c]) { } + } + + + function d5({x, y} = { x: 1, y: 2 }) { } + d5(); // Parameter is optional as its declaration included an initializer + + // Destructuring parameter declarations do not permit type annotations on the individual binding patterns, + // as such annotations would conflict with the already established meaning of colons in object literals. + // Type annotations must instead be written on the top- level parameter declaration + + function e1({x: number}) { } // x has type any NOT number + function e2({x}: { x: number }) { } // x is type number + function e3({x}: { x?: number }) { } // x is an optional with type number + function e4({x: [number,string,any] }) { } // x has type [any, any, any] + function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any] + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.js new file mode 100644 index 0000000000000..d903618603586 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.js @@ -0,0 +1,242 @@ +//// [destructuringParameterDeclaration1ES5iterable.ts] +// A parameter declaration may specify either an identifier or a binding pattern. +// The identifiers specified in parameter declarations and binding patterns +// in a parameter list must be unique within that parameter list. + +// If the declaration includes a type annotation, the parameter is of that type +function a1([a, b, [[c]]]: [number, number, string[][]]) { } +function a2(o: { x: number, a: number }) { } +function a3({j, k, l: {m, n}, q: [a, b, c]}: { j: number, k: string, l: { m: boolean, n: number }, q: (number|string)[] }) { }; +function a4({x, a}: { x: number, a: number }) { } + +a1([1, 2, [["world"]]]); +a1([1, 2, [["world"]], 3]); + +// If the declaration includes an initializer expression (which is permitted only +// when the parameter list occurs in conjunction with a function body), +// the parameter type is the widened form (section 3.11) of the type of the initializer expression. + +function b1(z = [undefined, null]) { }; +function b2(z = null, o = { x: 0, y: undefined }) { } +function b3({z: {x, y: {j}}} = { z: { x: "hi", y: { j: 1 } } }) { } + +interface F1 { + b5(z, y, [, a, b], {p, m: { q, r}}); +} + +function b6([a, z, y] = [undefined, null, undefined]) { } +function b7([[a], b, [[c, d]]] = [[undefined], undefined, [[undefined, undefined]]]) { } + +b1([1, 2, 3]); // z is widen to the type any[] +b2("string", { x: 200, y: "string" }); +b2("string", { x: 200, y: true }); +b6(["string", 1, 2]); // Shouldn't be an error +b7([["string"], 1, [[true, false]]]); // Shouldn't be an error + + +// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3) +enum Foo { a } +function c0({z: {x, y: {j}}}) { } +function c1({z} = { z: 10 }) { } +function c2({z = 10}) { } +function c3({b}: { b: number|string} = { b: "hello" }) { } +function c5([a, b, [[c]]]) { } +function c6([a, b, [[c=1]]]) { } + +c0({z : { x: 1, y: { j: "world" } }}); // Implied type is { z: {x: any, y: {j: any}} } +c0({z : { x: "string", y: { j: true } }}); // Implied type is { z: {x: any, y: {j: any}} } + +c1(); // Implied type is {z:number}? +c1({ z: 1 }) // Implied type is {z:number}? + +c2({}); // Implied type is {z?: number} +c2({z:1}); // Implied type is {z?: number} + +c3({ b: 1 }); // Implied type is { b: number|string }. + +c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]] +c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]] + +// A parameter can be marked optional by following its name or binding pattern with a question mark (?) +// or by including an initializer. + +function d0(x?) { } +function d0(x = 10) { } + +interface F2 { + d3([a, b, c]?); + d4({x, y, z}?); + e0([a, b, c]); +} + +class C2 implements F2 { + constructor() { } + d3() { } + d4() { } + e0([a, b, c]) { } +} + +class C3 implements F2 { + d3([a, b, c]) { } + d4({x, y, z}) { } + e0([a, b, c]) { } +} + + +function d5({x, y} = { x: 1, y: 2 }) { } +d5(); // Parameter is optional as its declaration included an initializer + +// Destructuring parameter declarations do not permit type annotations on the individual binding patterns, +// as such annotations would conflict with the already established meaning of colons in object literals. +// Type annotations must instead be written on the top- level parameter declaration + +function e1({x: number}) { } // x has type any NOT number +function e2({x}: { x: number }) { } // x is type number +function e3({x}: { x?: number }) { } // x is an optional with type number +function e4({x: [number,string,any] }) { } // x has type [any, any, any] +function e5({x: [a, b, c]}: { x: [number, number, number] }) { } // x has type [any, any, any] + + +//// [destructuringParameterDeclaration1ES5iterable.js] +// A parameter declaration may specify either an identifier or a binding pattern. +// The identifiers specified in parameter declarations and binding patterns +// in a parameter list must be unique within that parameter list. +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +// If the declaration includes a type annotation, the parameter is of that type +function a1(_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], _c = __read(_b[2], 1), _d = __read(_c[0], 1), c = _d[0]; +} +function a2(o) { } +function a3(_a) { + var j = _a.j, k = _a.k, _b = _a.l, m = _b.m, n = _b.n, _c = __read(_a.q, 3), a = _c[0], b = _c[1], c = _c[2]; +} +; +function a4(_a) { + var x = _a.x, a = _a.a; +} +a1([1, 2, [["world"]]]); +a1([1, 2, [["world"]], 3]); +// If the declaration includes an initializer expression (which is permitted only +// when the parameter list occurs in conjunction with a function body), +// the parameter type is the widened form (section 3.11) of the type of the initializer expression. +function b1(z) { + if (z === void 0) { z = [undefined, null]; } +} +; +function b2(z, o) { + if (z === void 0) { z = null; } + if (o === void 0) { o = { x: 0, y: undefined }; } +} +function b3(_a) { + var _b = (_a === void 0 ? { z: { x: "hi", y: { j: 1 } } } : _a).z, x = _b.x, j = _b.y.j; +} +function b6(_a) { + var _b = __read(_a === void 0 ? [undefined, null, undefined] : _a, 3), a = _b[0], z = _b[1], y = _b[2]; +} +function b7(_a) { + var _b = __read(_a === void 0 ? [[undefined], undefined, [[undefined, undefined]]] : _a, 3), _c = __read(_b[0], 1), a = _c[0], b = _b[1], _d = __read(_b[2], 1), _e = __read(_d[0], 2), c = _e[0], d = _e[1]; +} +b1([1, 2, 3]); // z is widen to the type any[] +b2("string", { x: 200, y: "string" }); +b2("string", { x: 200, y: true }); +b6(["string", 1, 2]); // Shouldn't be an error +b7([["string"], 1, [[true, false]]]); // Shouldn't be an error +// If the declaration specifies a binding pattern, the parameter type is the implied type of that binding pattern (section 5.1.3) +var Foo; +(function (Foo) { + Foo[Foo["a"] = 0] = "a"; +})(Foo || (Foo = {})); +function c0(_a) { + var _b = _a.z, x = _b.x, j = _b.y.j; +} +function c1(_a) { + var z = (_a === void 0 ? { z: 10 } : _a).z; +} +function c2(_a) { + var _b = _a.z, z = _b === void 0 ? 10 : _b; +} +function c3(_a) { + var b = (_a === void 0 ? { b: "hello" } : _a).b; +} +function c5(_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], _c = __read(_b[2], 1), _d = __read(_c[0], 1), c = _d[0]; +} +function c6(_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], _c = __read(_b[2], 1), _d = __read(_c[0], 1), _e = _d[0], c = _e === void 0 ? 1 : _e; +} +c0({ z: { x: 1, y: { j: "world" } } }); // Implied type is { z: {x: any, y: {j: any}} } +c0({ z: { x: "string", y: { j: true } } }); // Implied type is { z: {x: any, y: {j: any}} } +c1(); // Implied type is {z:number}? +c1({ z: 1 }); // Implied type is {z:number}? +c2({}); // Implied type is {z?: number} +c2({ z: 1 }); // Implied type is {z?: number} +c3({ b: 1 }); // Implied type is { b: number|string }. +c5([1, 2, [["string"]]]); // Implied type is is [any, any, [[any]]] +c5([1, 2, [["string"]], false, true]); // Implied type is is [any, any, [[any]]] +// A parameter can be marked optional by following its name or binding pattern with a question mark (?) +// or by including an initializer. +function d0(x) { } +function d0(x) { + if (x === void 0) { x = 10; } +} +var C2 = (function () { + function C2() { + } + C2.prototype.d3 = function () { }; + C2.prototype.d4 = function () { }; + C2.prototype.e0 = function (_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], c = _b[2]; + }; + return C2; +}()); +var C3 = (function () { + function C3() { + } + C3.prototype.d3 = function (_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], c = _b[2]; + }; + C3.prototype.d4 = function (_a) { + var x = _a.x, y = _a.y, z = _a.z; + }; + C3.prototype.e0 = function (_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], c = _b[2]; + }; + return C3; +}()); +function d5(_a) { + var _b = _a === void 0 ? { x: 1, y: 2 } : _a, x = _b.x, y = _b.y; +} +d5(); // Parameter is optional as its declaration included an initializer +// Destructuring parameter declarations do not permit type annotations on the individual binding patterns, +// as such annotations would conflict with the already established meaning of colons in object literals. +// Type annotations must instead be written on the top- level parameter declaration +function e1(_a) { + var number = _a.x; +} // x has type any NOT number +function e2(_a) { + var x = _a.x; +} // x is type number +function e3(_a) { + var x = _a.x; +} // x is an optional with type number +function e4(_a) { + var _b = __read(_a.x, 3), number = _b[0], string = _b[1], any = _b[2]; +} // x has type [any, any, any] +function e5(_a) { + var _b = __read(_a.x, 3), a = _b[0], b = _b[1], c = _b[2]; +} // x has type [any, any, any] diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js new file mode 100644 index 0000000000000..ab00e874e3e63 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.js @@ -0,0 +1,141 @@ +//// [destructuringParameterDeclaration3ES5iterable.ts] + +// If the parameter is a rest parameter, the parameter type is any[] +// A type annotation for a rest parameter must denote an array type. + +// RestParameter: +// ... Identifier TypeAnnotation(opt) + +type arrayString = Array +type someArray = Array | number[]; +type stringOrNumArray = Array; + +function a1(...x: (number|string)[]) { } +function a2(...a) { } +function a3(...a: Array) { } +function a4(...a: arrayString) { } +function a5(...a: stringOrNumArray) { } +function a9([a, b, [[c]]]) { } +function a10([a, b, [[c]], ...x]) { } +function a11([a, b, c, ...x]: number[]) { } + + +var array = [1, 2, 3]; +var array2 = [true, false, "hello"]; +a2([...array]); +a1(...array); + +a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] + +a10([1, 2, [["string"]], false, true]); // Parameter type is any[] +a10([1, 2, 3, false, true]); // Parameter type is any[] +a10([1, 2]); // Parameter type is any[] +a11([1, 2]); // Parameter type is number[] + +// Rest parameter with generic +function foo(...a: T[]) { } +foo("hello", 1, 2); +foo("hello", "world"); + +enum E { a, b } +const enum E1 { a, b } +function foo1(...a: T[]) { } +foo1(1, 2, 3, E.a); +foo1(1, 2, 3, E1.a, E.b); + + + + +//// [destructuringParameterDeclaration3ES5iterable.js] +// If the parameter is a rest parameter, the parameter type is any[] +// A type annotation for a rest parameter must denote an array type. +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +function a1() { + var x = []; + for (var _i = 0; _i < arguments.length; _i++) { + x[_i] = arguments[_i]; + } +} +function a2() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +function a3() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +function a4() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +function a5() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +function a9(_a) { + var _b = __read(_a, 3), a = _b[0], b = _b[1], _c = __read(_b[2], 1), _d = __read(_c[0], 1), c = _d[0]; +} +function a10(_a) { + var _b = __read(_a), a = _b[0], b = _b[1], _c = __read(_b[2], 1), _d = __read(_c[0], 1), c = _d[0], x = _b.slice(3); +} +function a11(_a) { + var _b = __read(_a), a = _b[0], b = _b[1], c = _b[2], x = _b.slice(3); +} +var array = [1, 2, 3]; +var array2 = [true, false, "hello"]; +a2(__spread(array)); +a1.apply(void 0, __spread(array)); +a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] +a10([1, 2, [["string"]], false, true]); // Parameter type is any[] +a10([1, 2, 3, false, true]); // Parameter type is any[] +a10([1, 2]); // Parameter type is any[] +a11([1, 2]); // Parameter type is number[] +// Rest parameter with generic +function foo() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +foo("hello", 1, 2); +foo("hello", "world"); +var E; +(function (E) { + E[E["a"] = 0] = "a"; + E[E["b"] = 1] = "b"; +})(E || (E = {})); +function foo1() { + var a = []; + for (var _i = 0; _i < arguments.length; _i++) { + a[_i] = arguments[_i]; + } +} +foo1(1, 2, 3, E.a); +foo1(1, 2, 3, 0 /* a */, E.b); diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols new file mode 100644 index 0000000000000..52b2d290fa08f --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.symbols @@ -0,0 +1,145 @@ +=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === + +// If the parameter is a rest parameter, the parameter type is any[] +// A type annotation for a rest parameter must denote an array type. + +// RestParameter: +// ... Identifier TypeAnnotation(opt) + +type arrayString = Array +>arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5iterable.ts, 0, 0)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +type someArray = Array | number[]; +>someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 7, 32)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +type stringOrNumArray = Array; +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +function a1(...x: (number|string)[]) { } +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 12)) + +function a2(...a) { } +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 12)) + +function a3(...a: Array) { } +>a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5iterable.ts, 12, 21)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 12)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +function a4(...a: arrayString) { } +>a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5iterable.ts, 13, 36)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 12)) +>arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5iterable.ts, 0, 0)) + +function a5(...a: stringOrNumArray) { } +>a5 : Symbol(a5, Decl(destructuringParameterDeclaration3ES5iterable.ts, 14, 34)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 12)) +>stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5iterable.ts, 8, 42)) + +function a9([a, b, [[c]]]) { } +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 13)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 15)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 21)) + +function a10([a, b, [[c]], ...x]) { } +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 22)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 26)) + +function a11([a, b, c, ...x]: number[]) { } +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 14)) +>b : Symbol(b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 16)) +>c : Symbol(c, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 19)) +>x : Symbol(x, Decl(destructuringParameterDeclaration3ES5iterable.ts, 18, 22)) + + +var array = [1, 2, 3]; +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) + +var array2 = [true, false, "hello"]; +>array2 : Symbol(array2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 22, 3)) + +a2([...array]); +>a2 : Symbol(a2, Decl(destructuringParameterDeclaration3ES5iterable.ts, 11, 40)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) + +a1(...array); +>a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 9, 45)) +>array : Symbol(array, Decl(destructuringParameterDeclaration3ES5iterable.ts, 21, 3)) + +a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] +>a9 : Symbol(a9, Decl(destructuringParameterDeclaration3ES5iterable.ts, 15, 39)) + +a10([1, 2, [["string"]], false, true]); // Parameter type is any[] +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) + +a10([1, 2, 3, false, true]); // Parameter type is any[] +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) + +a10([1, 2]); // Parameter type is any[] +>a10 : Symbol(a10, Decl(destructuringParameterDeclaration3ES5iterable.ts, 16, 30)) + +a11([1, 2]); // Parameter type is number[] +>a11 : Symbol(a11, Decl(destructuringParameterDeclaration3ES5iterable.ts, 17, 37)) + +// Rest parameter with generic +function foo(...a: T[]) { } +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 16)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 34, 13)) + +foo("hello", 1, 2); +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) + +foo("hello", "world"); +>foo : Symbol(foo, Decl(destructuringParameterDeclaration3ES5iterable.ts, 31, 12)) + +enum E { a, b } +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) + +const enum E1 { a, b } +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) +>b : Symbol(E1.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 18)) + +function foo1(...a: T[]) { } +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>a : Symbol(a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 32)) +>T : Symbol(T, Decl(destructuringParameterDeclaration3ES5iterable.ts, 40, 14)) + +foo1(1, 2, 3, E.a); +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) +>E.a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) +>a : Symbol(E.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 8)) + +foo1(1, 2, 3, E1.a, E.b); +>foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 22)) +>E1.a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) +>E1 : Symbol(E1, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 15)) +>a : Symbol(E1.a, Decl(destructuringParameterDeclaration3ES5iterable.ts, 39, 15)) +>E.b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) +>E : Symbol(E, Decl(destructuringParameterDeclaration3ES5iterable.ts, 36, 22)) +>b : Symbol(E.b, Decl(destructuringParameterDeclaration3ES5iterable.ts, 38, 11)) + + + diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types new file mode 100644 index 0000000000000..d003531c67b72 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types @@ -0,0 +1,206 @@ +=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5iterable.ts === + +// If the parameter is a rest parameter, the parameter type is any[] +// A type annotation for a rest parameter must denote an array type. + +// RestParameter: +// ... Identifier TypeAnnotation(opt) + +type arrayString = Array +>arrayString : String[] +>Array : T[] +>String : String + +type someArray = Array | number[]; +>someArray : someArray +>Array : T[] +>String : String + +type stringOrNumArray = Array; +>stringOrNumArray : (String | Number)[] +>Array : T[] +>String : String +>Number : Number + +function a1(...x: (number|string)[]) { } +>a1 : (...x: (string | number)[]) => void +>x : (string | number)[] + +function a2(...a) { } +>a2 : (...a: any[]) => void +>a : any[] + +function a3(...a: Array) { } +>a3 : (...a: String[]) => void +>a : String[] +>Array : T[] +>String : String + +function a4(...a: arrayString) { } +>a4 : (...a: String[]) => void +>a : String[] +>arrayString : String[] + +function a5(...a: stringOrNumArray) { } +>a5 : (...a: (String | Number)[]) => void +>a : (String | Number)[] +>stringOrNumArray : (String | Number)[] + +function a9([a, b, [[c]]]) { } +>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void +>a : any +>b : any +>c : any + +function a10([a, b, [[c]], ...x]) { } +>a10 : ([a, b, [[c]], ...x]: any[]) => void +>a : any +>b : any +>c : any +>x : any[] + +function a11([a, b, c, ...x]: number[]) { } +>a11 : ([a, b, c, ...x]: number[]) => void +>a : number +>b : number +>c : number +>x : number[] + + +var array = [1, 2, 3]; +>array : number[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + +var array2 = [true, false, "hello"]; +>array2 : (string | boolean)[] +>[true, false, "hello"] : (string | boolean)[] +>true : true +>false : false +>"hello" : "hello" + +a2([...array]); +>a2([...array]) : void +>a2 : (...a: any[]) => void +>[...array] : number[] +>...array : number +>array : number[] + +a1(...array); +>a1(...array) : void +>a1 : (...x: (string | number)[]) => void +>...array : number +>array : number[] + +a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]] +>a9([1, 2, [["string"]], false, true]) : void +>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void +>[1, 2, [["string"]], false, true] : [number, number, [[string]], boolean, boolean] +>1 : 1 +>2 : 2 +>[["string"]] : [[string]] +>["string"] : [string] +>"string" : "string" +>false : false +>true : true + +a10([1, 2, [["string"]], false, true]); // Parameter type is any[] +>a10([1, 2, [["string"]], false, true]) : void +>a10 : ([a, b, [[c]], ...x]: any[]) => void +>[1, 2, [["string"]], false, true] : (number | boolean | string[][])[] +>1 : 1 +>2 : 2 +>[["string"]] : string[][] +>["string"] : string[] +>"string" : "string" +>false : false +>true : true + +a10([1, 2, 3, false, true]); // Parameter type is any[] +>a10([1, 2, 3, false, true]) : void +>a10 : ([a, b, [[c]], ...x]: any[]) => void +>[1, 2, 3, false, true] : (number | boolean)[] +>1 : 1 +>2 : 2 +>3 : 3 +>false : false +>true : true + +a10([1, 2]); // Parameter type is any[] +>a10([1, 2]) : void +>a10 : ([a, b, [[c]], ...x]: any[]) => void +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +a11([1, 2]); // Parameter type is number[] +>a11([1, 2]) : void +>a11 : ([a, b, c, ...x]: number[]) => void +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +// Rest parameter with generic +function foo(...a: T[]) { } +>foo : (...a: T[]) => void +>T : T +>a : T[] +>T : T + +foo("hello", 1, 2); +>foo("hello", 1, 2) : void +>foo : (...a: T[]) => void +>"hello" : "hello" +>1 : 1 +>2 : 2 + +foo("hello", "world"); +>foo("hello", "world") : void +>foo : (...a: T[]) => void +>"hello" : "hello" +>"world" : "world" + +enum E { a, b } +>E : E +>a : E.a +>b : E.b + +const enum E1 { a, b } +>E1 : E1 +>a : E1.a +>b : E1.b + +function foo1(...a: T[]) { } +>foo1 : (...a: T[]) => void +>T : T +>Number : Number +>a : T[] +>T : T + +foo1(1, 2, 3, E.a); +>foo1(1, 2, 3, E.a) : void +>foo1 : (...a: T[]) => void +>1 : 1 +>2 : 2 +>3 : 3 +>E.a : E.a +>E : typeof E +>a : E.a + +foo1(1, 2, 3, E1.a, E.b); +>foo1(1, 2, 3, E1.a, E.b) : void +>foo1 : (...a: T[]) => void +>1 : 1 +>2 : 2 +>3 : 3 +>E1.a : E1.a +>E1 : typeof E1 +>a : E1.a +>E.b : E.b +>E : typeof E +>b : E.b + + + diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js new file mode 100644 index 0000000000000..818ea428c1d29 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.js @@ -0,0 +1,43 @@ +//// [destructuringParameterDeclaration7ES5iterable.ts] + +interface ISomething { + foo: string, + bar: string +} + +function foo({}, {foo, bar}: ISomething) {} + +function baz([], {foo, bar}: ISomething) {} + +function one([], {}) {} + +function two([], [a, b, c]: number[]) {} + + +//// [destructuringParameterDeclaration7ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +function foo(_a, _b) { + var foo = _b.foo, bar = _b.bar; +} +function baz(_a, _b) { + var foo = _b.foo, bar = _b.bar; +} +function one(_a, _b) { } +function two(_a, _b) { + var _c = __read(_b, 3), a = _c[0], b = _c[1], c = _c[2]; +} diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols new file mode 100644 index 0000000000000..0548f1247f6d3 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === + +interface ISomething { +>ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) + + foo: string, +>foo : Symbol(ISomething.foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 1, 22)) + + bar: string +>bar : Symbol(ISomething.bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 2, 16)) +} + +function foo({}, {foo, bar}: ISomething) {} +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 4, 1)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 22)) +>ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) + +function baz([], {foo, bar}: ISomething) {} +>baz : Symbol(baz, Decl(destructuringParameterDeclaration7ES5iterable.ts, 6, 43)) +>foo : Symbol(foo, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 18)) +>bar : Symbol(bar, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 22)) +>ISomething : Symbol(ISomething, Decl(destructuringParameterDeclaration7ES5iterable.ts, 0, 0)) + +function one([], {}) {} +>one : Symbol(one, Decl(destructuringParameterDeclaration7ES5iterable.ts, 8, 43)) + +function two([], [a, b, c]: number[]) {} +>two : Symbol(two, Decl(destructuringParameterDeclaration7ES5iterable.ts, 10, 23)) +>a : Symbol(a, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 18)) +>b : Symbol(b, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 20)) +>c : Symbol(c, Decl(destructuringParameterDeclaration7ES5iterable.ts, 12, 23)) + diff --git a/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types new file mode 100644 index 0000000000000..402ea7ac5e161 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterDeclaration7ES5iterable.types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration7ES5iterable.ts === + +interface ISomething { +>ISomething : ISomething + + foo: string, +>foo : string + + bar: string +>bar : string +} + +function foo({}, {foo, bar}: ISomething) {} +>foo : ({}: {}, {foo, bar}: ISomething) => void +>foo : string +>bar : string +>ISomething : ISomething + +function baz([], {foo, bar}: ISomething) {} +>baz : ([]: any[], {foo, bar}: ISomething) => void +>foo : string +>bar : string +>ISomething : ISomething + +function one([], {}) {} +>one : ([]: any[], {}: {}) => void + +function two([], [a, b, c]: number[]) {} +>two : ([]: any[], [a, b, c]: number[]) => void +>a : number +>b : number +>c : number + diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.js b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.js new file mode 100644 index 0000000000000..83fb3de04fc1e --- /dev/null +++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.js @@ -0,0 +1,97 @@ +//// [destructuringVariableDeclaration1ES5iterable.ts] +// The type T associated with a destructuring variable declaration is determined as follows: +// If the declaration includes a type annotation, T is that type. +var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" } +var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true]; + +// The type T associated with a destructuring variable declaration is determined as follows: +// Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression. +var { b1: { b11 } = { b11: "string" } } = { b1: { b11: "world" } }; +var temp = { t1: true, t2: "false" }; +var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }]; +var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined]; + +// The type T associated with a binding element is determined as follows: +// If the binding element is a rest element, T is an array type with +// an element type E, where E is the type of the numeric index signature of S. +var [...c1] = [1,2,3]; +var [...c2] = [1,2,3, "string"]; + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Let N be the zero-based index of the binding element in the array binding pattern. +// If S has a property with the numerical name N, T is the type of that property. +var [d1,d2] = [1,"string"] + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Otherwise, if S has a numeric index signature, T is the type of the numeric index signature. +var temp1 = [true, false, true] +var [d3, d4] = [1, "string", ...temp1]; + +// Combining both forms of destructuring, +var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; +var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] }; + +// When a destructuring variable declaration, binding property, or binding element specifies +// an initializer expression, the type of the initializer expression is required to be assignable +// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element. +var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } }; +var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } }; + + + +//// [destructuringVariableDeclaration1ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +// The type T associated with a destructuring variable declaration is determined as follows: +// If the declaration includes a type annotation, T is that type. +var _a = { a1: 10, a2: "world" }, a1 = _a.a1, a2 = _a.a2; +var _b = __read([1, [["hello"]], true], 3), a3 = _b[0], _c = __read(_b[1], 1), _d = __read(_c[0], 1), a4 = _d[0], a5 = _b[2]; +// The type T associated with a destructuring variable declaration is determined as follows: +// Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression. +var _e = { b1: { b11: "world" } }.b1, b11 = (_e === void 0 ? { b11: "string" } : _e).b11; +var temp = { t1: true, t2: "false" }; +var _f = __read([3, false, { t1: false, t2: "hello" }], 3), _g = _f[0], b2 = _g === void 0 ? 3 : _g, _h = _f[1], b3 = _h === void 0 ? true : _h, _j = _f[2], b4 = _j === void 0 ? temp : _j; +var _k = __read([undefined, undefined, undefined], 3), _l = _k[0], b5 = _l === void 0 ? 3 : _l, _m = _k[1], b6 = _m === void 0 ? true : _m, _o = _k[2], b7 = _o === void 0 ? temp : _o; +// The type T associated with a binding element is determined as follows: +// If the binding element is a rest element, T is an array type with +// an element type E, where E is the type of the numeric index signature of S. +var _p = __read([1, 2, 3]), c1 = _p.slice(0); +var _q = __read([1, 2, 3, "string"]), c2 = _q.slice(0); +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Let N be the zero-based index of the binding element in the array binding pattern. +// If S has a property with the numerical name N, T is the type of that property. +var _r = __read([1, "string"], 2), d1 = _r[0], d2 = _r[1]; +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Otherwise, if S has a numeric index signature, T is the type of the numeric index signature. +var temp1 = [true, false, true]; +var _s = __read(__spread([1, "string"], temp1), 2), d3 = _s[0], d4 = _s[1]; +// Combining both forms of destructuring, +var _t = __read({ e: [1, 2, { b1: 4, b4: 0 }] }.e, 3), e1 = _t[0], e2 = _t[1], _u = _t[2], e3 = _u === void 0 ? { b1: 1000, b4: 200 } : _u; +var _v = __read({ f: [1, 2, { f3: 4, f5: 0 }] }.f, 4), f1 = _v[0], f2 = _v[1], _w = _v[2], f4 = _w.f3, f5 = _w.f5; +// When a destructuring variable declaration, binding property, or binding element specifies +// an initializer expression, the type of the initializer expression is required to be assignable +// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element. +var _x = { g: { g1: [1, 2] } }.g.g1, g1 = _x === void 0 ? [undefined, null] : _x; +var _y = { h: { h1: [1, 2] } }.h.h1, h1 = _y === void 0 ? [undefined, null] : _y; diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.symbols b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.symbols new file mode 100644 index 0000000000000..b0ed4280cb65c --- /dev/null +++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.symbols @@ -0,0 +1,120 @@ +=== tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration1ES5iterable.ts === +// The type T associated with a destructuring variable declaration is determined as follows: +// If the declaration includes a type annotation, T is that type. +var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" } +>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 5)) +>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 8)) +>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 15)) +>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 27)) +>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 44)) +>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 2, 52)) + +var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true]; +>a3 : Symbol(a3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 3, 5)) +>a4 : Symbol(a4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 3, 11)) +>a5 : Symbol(a5, Decl(destructuringVariableDeclaration1ES5iterable.ts, 3, 16)) + +// The type T associated with a destructuring variable declaration is determined as follows: +// Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression. +var { b1: { b11 } = { b11: "string" } } = { b1: { b11: "world" } }; +>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 7, 44)) +>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5iterable.ts, 7, 11)) +>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5iterable.ts, 7, 21)) +>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 7, 44)) +>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5iterable.ts, 7, 50)) + +var temp = { t1: true, t2: "false" }; +>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5iterable.ts, 8, 3)) +>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 8, 12)) +>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 8, 22)) + +var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }]; +>b2 : Symbol(b2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 9, 5)) +>b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 9, 12)) +>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 9, 23)) +>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5iterable.ts, 8, 3)) +>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 9, 49)) +>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 9, 60)) + +var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined]; +>b5 : Symbol(b5, Decl(destructuringVariableDeclaration1ES5iterable.ts, 10, 5)) +>b6 : Symbol(b6, Decl(destructuringVariableDeclaration1ES5iterable.ts, 10, 12)) +>b7 : Symbol(b7, Decl(destructuringVariableDeclaration1ES5iterable.ts, 10, 23)) +>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5iterable.ts, 8, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// The type T associated with a binding element is determined as follows: +// If the binding element is a rest element, T is an array type with +// an element type E, where E is the type of the numeric index signature of S. +var [...c1] = [1,2,3]; +>c1 : Symbol(c1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 15, 5)) + +var [...c2] = [1,2,3, "string"]; +>c2 : Symbol(c2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 16, 5)) + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Let N be the zero-based index of the binding element in the array binding pattern. +// If S has a property with the numerical name N, T is the type of that property. +var [d1,d2] = [1,"string"] +>d1 : Symbol(d1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 22, 5)) +>d2 : Symbol(d2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 22, 8)) + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Otherwise, if S has a numeric index signature, T is the type of the numeric index signature. +var temp1 = [true, false, true] +>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 27, 3)) + +var [d3, d4] = [1, "string", ...temp1]; +>d3 : Symbol(d3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 28, 5)) +>d4 : Symbol(d4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 28, 8)) +>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 27, 3)) + +// Combining both forms of destructuring, +var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; +>e : Symbol(e, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 49)) +>e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 9)) +>e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 12)) +>e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 16)) +>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 23)) +>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 33)) +>e : Symbol(e, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 49)) +>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 61)) +>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 31, 68)) + +var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] }; +>f : Symbol(f, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 41)) +>f1 : Symbol(f1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 9)) +>f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 12)) +>f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 53)) +>f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 18)) +>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 26)) +>f : Symbol(f, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 41)) +>f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 53)) +>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5iterable.ts, 32, 60)) + +// When a destructuring variable declaration, binding property, or binding element specifies +// an initializer expression, the type of the initializer expression is required to be assignable +// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element. +var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } }; +>g : Symbol(g, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 36)) +>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 9)) +>undefined : Symbol(undefined) +>g : Symbol(g, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 36)) +>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 41)) +>g : Symbol(g, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 59)) +>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 37, 64)) + +var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } }; +>h : Symbol(h, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 36)) +>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 9)) +>undefined : Symbol(undefined) +>h : Symbol(h, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 36)) +>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 41)) +>h : Symbol(h, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 62)) +>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5iterable.ts, 38, 67)) + + diff --git a/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.types b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.types new file mode 100644 index 0000000000000..6ef4c3d574979 --- /dev/null +++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5iterable.types @@ -0,0 +1,200 @@ +=== tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration1ES5iterable.ts === +// The type T associated with a destructuring variable declaration is determined as follows: +// If the declaration includes a type annotation, T is that type. +var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" } +>a1 : number +>a2 : string +>a1 : number +>a2 : string +>{ a1: 10, a2: "world" } : { a1: number; a2: string; } +>a1 : number +>10 : 10 +>a2 : string +>"world" : "world" + +var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true]; +>a3 : number +>a4 : string +>a5 : boolean +>[1, [["hello"]], true] : [number, [[string]], true] +>1 : 1 +>[["hello"]] : [[string]] +>["hello"] : [string] +>"hello" : "hello" +>true : true + +// The type T associated with a destructuring variable declaration is determined as follows: +// Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression. +var { b1: { b11 } = { b11: "string" } } = { b1: { b11: "world" } }; +>b1 : any +>b11 : string +>{ b11: "string" } : { b11: string; } +>b11 : string +>"string" : "string" +>{ b1: { b11: "world" } } : { b1?: { b11: string; }; } +>b1 : { b11: string; } +>{ b11: "world" } : { b11: string; } +>b11 : string +>"world" : "world" + +var temp = { t1: true, t2: "false" }; +>temp : { t1: boolean; t2: string; } +>{ t1: true, t2: "false" } : { t1: boolean; t2: string; } +>t1 : boolean +>true : true +>t2 : string +>"false" : "false" + +var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }]; +>b2 : number +>3 : 3 +>b3 : boolean +>true : true +>b4 : { t1: boolean; t2: string; } +>temp : { t1: boolean; t2: string; } +>[3, false, { t1: false, t2: "hello" }] : [number, false, { t1: false; t2: string; }] +>3 : 3 +>false : false +>{ t1: false, t2: "hello" } : { t1: false; t2: string; } +>t1 : boolean +>false : false +>t2 : string +>"hello" : "hello" + +var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined]; +>b5 : 3 +>3 : 3 +>b6 : true +>true : true +>b7 : { t1: boolean; t2: string; } +>temp : { t1: boolean; t2: string; } +>[undefined, undefined, undefined] : [undefined, undefined, undefined] +>undefined : undefined +>undefined : undefined +>undefined : undefined + +// The type T associated with a binding element is determined as follows: +// If the binding element is a rest element, T is an array type with +// an element type E, where E is the type of the numeric index signature of S. +var [...c1] = [1,2,3]; +>c1 : number[] +>[1,2,3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + +var [...c2] = [1,2,3, "string"]; +>c2 : (string | number)[] +>[1,2,3, "string"] : (string | number)[] +>1 : 1 +>2 : 2 +>3 : 3 +>"string" : "string" + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Let N be the zero-based index of the binding element in the array binding pattern. +// If S has a property with the numerical name N, T is the type of that property. +var [d1,d2] = [1,"string"] +>d1 : number +>d2 : string +>[1,"string"] : [number, string] +>1 : 1 +>"string" : "string" + +// The type T associated with a binding element is determined as follows: +// Otherwise, if S is a tuple- like type (section 3.3.3): +// Otherwise, if S has a numeric index signature, T is the type of the numeric index signature. +var temp1 = [true, false, true] +>temp1 : boolean[] +>[true, false, true] : boolean[] +>true : true +>false : false +>true : true + +var [d3, d4] = [1, "string", ...temp1]; +>d3 : string | number | boolean +>d4 : string | number | boolean +>[1, "string", ...temp1] : (string | number | boolean)[] +>1 : 1 +>"string" : "string" +>...temp1 : boolean +>temp1 : boolean[] + +// Combining both forms of destructuring, +var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; +>e : any +>e1 : number +>e2 : number +>e3 : { b1: number; b4: number; } +>{ b1: 1000, b4: 200 } : { b1: number; b4: number; } +>b1 : number +>1000 : 1000 +>b4 : number +>200 : 200 +>{ e: [1, 2, { b1: 4, b4: 0 }] } : { e: [number, number, { b1: number; b4: number; }]; } +>e : [number, number, { b1: number; b4: number; }] +>[1, 2, { b1: 4, b4: 0 }] : [number, number, { b1: number; b4: number; }] +>1 : 1 +>2 : 2 +>{ b1: 4, b4: 0 } : { b1: number; b4: number; } +>b1 : number +>4 : 4 +>b4 : number +>0 : 0 + +var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] }; +>f : any +>f1 : number +>f2 : number +>f3 : any +>f4 : number +>f5 : number +> : undefined +>{ f: [1, 2, { f3: 4, f5: 0 }] } : { f: [number, number, { f3: number; f5: number; }, any]; } +>f : [number, number, { f3: number; f5: number; }, any] +>[1, 2, { f3: 4, f5: 0 }] : [number, number, { f3: number; f5: number; }, any] +>1 : 1 +>2 : 2 +>{ f3: 4, f5: 0 } : { f3: number; f5: number; } +>f3 : number +>4 : 4 +>f5 : number +>0 : 0 + +// When a destructuring variable declaration, binding property, or binding element specifies +// an initializer expression, the type of the initializer expression is required to be assignable +// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element. +var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } }; +>g : any +>g1 : any[] +>[undefined, null] : null[] +>undefined : undefined +>null : null +>g : { g1: any[]; } +>g1 : any[] +>{ g: { g1: [1, 2] } } : { g: { g1: number[]; }; } +>g : { g1: number[]; } +>{ g1: [1, 2] } : { g1: number[]; } +>g1 : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } }; +>h : any +>h1 : number[] +>[undefined, null] : null[] +>undefined : undefined +>null : null +>h : { h1: number[]; } +>h1 : number[] +>{ h: { h1: [1, 2] } } : { h: { h1: number[]; }; } +>h : { h1: number[]; } +>{ h1: [1, 2] } : { h1: number[]; } +>h1 : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 + + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js new file mode 100644 index 0000000000000..2edcfd99e4b5f --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js @@ -0,0 +1,257 @@ +//// [tests/cases/conformance/emitter/es2015/asyncGenerators/emitter.asyncGenerators.classMethods.es2015.ts] //// + +//// [C1.ts] +class C1 { + async * f() { + } +} +//// [C2.ts] +class C2 { + async * f() { + const x = yield; + } +} +//// [C3.ts] +class C3 { + async * f() { + const x = yield 1; + } +} +//// [C4.ts] +class C4 { + async * f() { + const x = yield* [1]; + } +} +//// [C5.ts] +class C5 { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [C6.ts] +class C6 { + async * f() { + const x = await 1; + } +} +//// [C7.ts] +class C7 { + async * f() { + return 1; + } +} +//// [C8.ts] +class C8 { + g() { + } + async * f() { + this.g(); + } +} +//// [C9.ts] +class B9 { + g() {} +} +class C9 extends B9 { + async * f() { + super.g(); + } +} + + +//// [C1.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C1 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + }); + } +} +//// [C2.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C2 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["yield"]; + }); + } +} +//// [C3.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C3 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["yield", 1]; + }); + } +} +//// [C4.js] +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C4 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield* __asyncDelegator([1]); + }); + } +} +//// [C5.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +class C5 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield* __asyncDelegator((function () { return __asyncGenerator(this, arguments, function* () { yield ["yield", 1]; }); })()); + }); + } +} +//// [C6.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C6 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["await", 1]; + }); + } +} +//// [C7.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C7 { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + return 1; + }); + } +} +//// [C8.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class C8 { + g() { + } + f() { + return __asyncGenerator(this, arguments, function* f_1() { + this.g(); + }); + } +} +//// [C9.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +class B9 { + g() { } +} +class C9 extends B9 { + f() { + const _super = name => super[name]; + return __asyncGenerator(this, arguments, function* f_1() { + _super("g").call(this); + }); + } +} diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.symbols b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.symbols new file mode 100644 index 0000000000000..5db32d5c4d8a3 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.symbols @@ -0,0 +1,110 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C1.ts === +class C1 { +>C1 : Symbol(C1, Decl(C1.ts, 0, 0)) + + async * f() { +>f : Symbol(C1.f, Decl(C1.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C2.ts === +class C2 { +>C2 : Symbol(C2, Decl(C2.ts, 0, 0)) + + async * f() { +>f : Symbol(C2.f, Decl(C2.ts, 0, 10)) + + const x = yield; +>x : Symbol(x, Decl(C2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C3.ts === +class C3 { +>C3 : Symbol(C3, Decl(C3.ts, 0, 0)) + + async * f() { +>f : Symbol(C3.f, Decl(C3.ts, 0, 10)) + + const x = yield 1; +>x : Symbol(x, Decl(C3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C4.ts === +class C4 { +>C4 : Symbol(C4, Decl(C4.ts, 0, 0)) + + async * f() { +>f : Symbol(C4.f, Decl(C4.ts, 0, 10)) + + const x = yield* [1]; +>x : Symbol(x, Decl(C4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C5.ts === +class C5 { +>C5 : Symbol(C5, Decl(C5.ts, 0, 0)) + + async * f() { +>f : Symbol(C5.f, Decl(C5.ts, 0, 10)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(C5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C6.ts === +class C6 { +>C6 : Symbol(C6, Decl(C6.ts, 0, 0)) + + async * f() { +>f : Symbol(C6.f, Decl(C6.ts, 0, 10)) + + const x = await 1; +>x : Symbol(x, Decl(C6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C7.ts === +class C7 { +>C7 : Symbol(C7, Decl(C7.ts, 0, 0)) + + async * f() { +>f : Symbol(C7.f, Decl(C7.ts, 0, 10)) + + return 1; + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C8.ts === +class C8 { +>C8 : Symbol(C8, Decl(C8.ts, 0, 0)) + + g() { +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } + async * f() { +>f : Symbol(C8.f, Decl(C8.ts, 2, 5)) + + this.g(); +>this.g : Symbol(C8.g, Decl(C8.ts, 0, 10)) +>this : Symbol(C8, Decl(C8.ts, 0, 0)) +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C9.ts === +class B9 { +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + g() {} +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +} +class C9 extends B9 { +>C9 : Symbol(C9, Decl(C9.ts, 2, 1)) +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + async * f() { +>f : Symbol(C9.f, Decl(C9.ts, 3, 21)) + + super.g(); +>super.g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +>super : Symbol(B9, Decl(C9.ts, 0, 0)) +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types new file mode 100644 index 0000000000000..524f7c9b71b2b --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types @@ -0,0 +1,127 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C1.ts === +class C1 { +>C1 : C1 + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C2.ts === +class C2 { +>C2 : C2 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C3.ts === +class C3 { +>C3 : C3 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C4.ts === +class C4 { +>C4 : C4 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C5.ts === +class C5 { +>C5 : C5 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C6.ts === +class C6 { +>C6 : C6 + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C7.ts === +class C7 { +>C7 : C7 + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C8.ts === +class C8 { +>C8 : C8 + + g() { +>g : () => void + } + async * f() { +>f : () => AsyncIterableIterator + + this.g(); +>this.g() : void +>this.g : () => void +>this : this +>g : () => void + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/C9.ts === +class B9 { +>B9 : B9 + + g() {} +>g : () => void +} +class C9 extends B9 { +>C9 : C9 +>B9 : B9 + + async * f() { +>f : () => AsyncIterableIterator + + super.g(); +>super.g() : void +>super.g : () => void +>super : B9 +>g : () => void + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js new file mode 100644 index 0000000000000..2b296936368de --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js @@ -0,0 +1,619 @@ +//// [tests/cases/conformance/emitter/es5/asyncGenerators/emitter.asyncGenerators.classMethods.es5.ts] //// + +//// [C1.ts] +class C1 { + async * f() { + } +} +//// [C2.ts] +class C2 { + async * f() { + const x = yield; + } +} +//// [C3.ts] +class C3 { + async * f() { + const x = yield 1; + } +} +//// [C4.ts] +class C4 { + async * f() { + const x = yield* [1]; + } +} +//// [C5.ts] +class C5 { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [C6.ts] +class C6 { + async * f() { + const x = await 1; + } +} +//// [C7.ts] +class C7 { + async * f() { + return 1; + } +} +//// [C8.ts] +class C8 { + g() { + } + async * f() { + this.g(); + } +} +//// [C9.ts] +class B9 { + g() {} +} +class C9 extends B9 { + async * f() { + super.g(); + } +} + + +//// [C1.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C1 = (function () { + function C1() { + } + C1.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + return [2 /*return*/]; + }); + }); + }; + return C1; +}()); +//// [C2.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C2 = (function () { + function C2() { + } + C2.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield"]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + return C2; +}()); +//// [C3.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C3 = (function () { + function C3() { + } + C3.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + return C3; +}()); +//// [C4.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var C4 = (function () { + function C4() { + } + C4.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator([1]))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + return C4; +}()); +//// [C5.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var C5 = (function () { + function C5() { + } + C5.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator((function () { return __asyncGenerator(this, arguments, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); }); })()))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + return C5; +}()); +//// [C6.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C6 = (function () { + function C6() { + } + C6.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["await", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + }; + return C6; +}()); +//// [C7.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C7 = (function () { + function C7() { + } + C7.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + return [2 /*return*/, 1]; + }); + }); + }; + return C7; +}()); +//// [C8.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var C8 = (function () { + function C8() { + } + C8.prototype.g = function () { + }; + C8.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + this.g(); + return [2 /*return*/]; + }); + }); + }; + return C8; +}()); +//// [C9.js] +var __extends = (this && this.__extends) || (function () { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var B9 = (function () { + function B9() { + } + B9.prototype.g = function () { }; + return B9; +}()); +var C9 = (function (_super) { + __extends(C9, _super); + function C9() { + return _super !== null && _super.apply(this, arguments) || this; + } + C9.prototype.f = function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + _super.prototype.g.call(this); + return [2 /*return*/]; + }); + }); + }; + return C9; +}(B9)); diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.symbols b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.symbols new file mode 100644 index 0000000000000..de82f07faacaf --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.symbols @@ -0,0 +1,110 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/C1.ts === +class C1 { +>C1 : Symbol(C1, Decl(C1.ts, 0, 0)) + + async * f() { +>f : Symbol(C1.f, Decl(C1.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C2.ts === +class C2 { +>C2 : Symbol(C2, Decl(C2.ts, 0, 0)) + + async * f() { +>f : Symbol(C2.f, Decl(C2.ts, 0, 10)) + + const x = yield; +>x : Symbol(x, Decl(C2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C3.ts === +class C3 { +>C3 : Symbol(C3, Decl(C3.ts, 0, 0)) + + async * f() { +>f : Symbol(C3.f, Decl(C3.ts, 0, 10)) + + const x = yield 1; +>x : Symbol(x, Decl(C3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C4.ts === +class C4 { +>C4 : Symbol(C4, Decl(C4.ts, 0, 0)) + + async * f() { +>f : Symbol(C4.f, Decl(C4.ts, 0, 10)) + + const x = yield* [1]; +>x : Symbol(x, Decl(C4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C5.ts === +class C5 { +>C5 : Symbol(C5, Decl(C5.ts, 0, 0)) + + async * f() { +>f : Symbol(C5.f, Decl(C5.ts, 0, 10)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(C5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C6.ts === +class C6 { +>C6 : Symbol(C6, Decl(C6.ts, 0, 0)) + + async * f() { +>f : Symbol(C6.f, Decl(C6.ts, 0, 10)) + + const x = await 1; +>x : Symbol(x, Decl(C6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C7.ts === +class C7 { +>C7 : Symbol(C7, Decl(C7.ts, 0, 0)) + + async * f() { +>f : Symbol(C7.f, Decl(C7.ts, 0, 10)) + + return 1; + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C8.ts === +class C8 { +>C8 : Symbol(C8, Decl(C8.ts, 0, 0)) + + g() { +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } + async * f() { +>f : Symbol(C8.f, Decl(C8.ts, 2, 5)) + + this.g(); +>this.g : Symbol(C8.g, Decl(C8.ts, 0, 10)) +>this : Symbol(C8, Decl(C8.ts, 0, 0)) +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C9.ts === +class B9 { +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + g() {} +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +} +class C9 extends B9 { +>C9 : Symbol(C9, Decl(C9.ts, 2, 1)) +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + async * f() { +>f : Symbol(C9.f, Decl(C9.ts, 3, 21)) + + super.g(); +>super.g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +>super : Symbol(B9, Decl(C9.ts, 0, 0)) +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types new file mode 100644 index 0000000000000..c20e0d3501072 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types @@ -0,0 +1,127 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/C1.ts === +class C1 { +>C1 : C1 + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C2.ts === +class C2 { +>C2 : C2 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C3.ts === +class C3 { +>C3 : C3 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C4.ts === +class C4 { +>C4 : C4 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C5.ts === +class C5 { +>C5 : C5 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C6.ts === +class C6 { +>C6 : C6 + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C7.ts === +class C7 { +>C7 : C7 + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C8.ts === +class C8 { +>C8 : C8 + + g() { +>g : () => void + } + async * f() { +>f : () => AsyncIterableIterator + + this.g(); +>this.g() : void +>this.g : () => void +>this : this +>g : () => void + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/C9.ts === +class B9 { +>B9 : B9 + + g() {} +>g : () => void +} +class C9 extends B9 { +>C9 : C9 +>B9 : B9 + + async * f() { +>f : () => AsyncIterableIterator + + super.g(); +>super.g() : void +>super.g : () => void +>super : B9 +>g : () => void + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js new file mode 100644 index 0000000000000..84c8aaf009bb4 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js @@ -0,0 +1,120 @@ +//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts] //// + +//// [C1.ts] +class C1 { + async * f() { + } +} +//// [C2.ts] +class C2 { + async * f() { + const x = yield; + } +} +//// [C3.ts] +class C3 { + async * f() { + const x = yield 1; + } +} +//// [C4.ts] +class C4 { + async * f() { + const x = yield* [1]; + } +} +//// [C5.ts] +class C5 { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [C6.ts] +class C6 { + async * f() { + const x = await 1; + } +} +//// [C7.ts] +class C7 { + async * f() { + return 1; + } +} +//// [C8.ts] +class C8 { + g() { + } + async * f() { + this.g(); + } +} +//// [C9.ts] +class B9 { + g() {} +} +class C9 extends B9 { + async * f() { + super.g(); + } +} + + +//// [C1.js] +class C1 { + async *f() { + } +} +//// [C2.js] +class C2 { + async *f() { + const x = yield; + } +} +//// [C3.js] +class C3 { + async *f() { + const x = yield 1; + } +} +//// [C4.js] +class C4 { + async *f() { + const x = yield* [1]; + } +} +//// [C5.js] +class C5 { + async *f() { + const x = yield* (async function* () { yield 1; })(); + } +} +//// [C6.js] +class C6 { + async *f() { + const x = await 1; + } +} +//// [C7.js] +class C7 { + async *f() { + return 1; + } +} +//// [C8.js] +class C8 { + g() { + } + async *f() { + this.g(); + } +} +//// [C9.js] +class B9 { + g() { } +} +class C9 extends B9 { + async *f() { + super.g(); + } +} diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols new file mode 100644 index 0000000000000..99450781f82ea --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols @@ -0,0 +1,110 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +class C1 { +>C1 : Symbol(C1, Decl(C1.ts, 0, 0)) + + async * f() { +>f : Symbol(C1.f, Decl(C1.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +class C2 { +>C2 : Symbol(C2, Decl(C2.ts, 0, 0)) + + async * f() { +>f : Symbol(C2.f, Decl(C2.ts, 0, 10)) + + const x = yield; +>x : Symbol(x, Decl(C2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +class C3 { +>C3 : Symbol(C3, Decl(C3.ts, 0, 0)) + + async * f() { +>f : Symbol(C3.f, Decl(C3.ts, 0, 10)) + + const x = yield 1; +>x : Symbol(x, Decl(C3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +class C4 { +>C4 : Symbol(C4, Decl(C4.ts, 0, 0)) + + async * f() { +>f : Symbol(C4.f, Decl(C4.ts, 0, 10)) + + const x = yield* [1]; +>x : Symbol(x, Decl(C4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +class C5 { +>C5 : Symbol(C5, Decl(C5.ts, 0, 0)) + + async * f() { +>f : Symbol(C5.f, Decl(C5.ts, 0, 10)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(C5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +class C6 { +>C6 : Symbol(C6, Decl(C6.ts, 0, 0)) + + async * f() { +>f : Symbol(C6.f, Decl(C6.ts, 0, 10)) + + const x = await 1; +>x : Symbol(x, Decl(C6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +class C7 { +>C7 : Symbol(C7, Decl(C7.ts, 0, 0)) + + async * f() { +>f : Symbol(C7.f, Decl(C7.ts, 0, 10)) + + return 1; + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +class C8 { +>C8 : Symbol(C8, Decl(C8.ts, 0, 0)) + + g() { +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } + async * f() { +>f : Symbol(C8.f, Decl(C8.ts, 2, 5)) + + this.g(); +>this.g : Symbol(C8.g, Decl(C8.ts, 0, 10)) +>this : Symbol(C8, Decl(C8.ts, 0, 0)) +>g : Symbol(C8.g, Decl(C8.ts, 0, 10)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +class B9 { +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + g() {} +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +} +class C9 extends B9 { +>C9 : Symbol(C9, Decl(C9.ts, 2, 1)) +>B9 : Symbol(B9, Decl(C9.ts, 0, 0)) + + async * f() { +>f : Symbol(C9.f, Decl(C9.ts, 3, 21)) + + super.g(); +>super.g : Symbol(B9.g, Decl(C9.ts, 0, 10)) +>super : Symbol(B9, Decl(C9.ts, 0, 0)) +>g : Symbol(B9.g, Decl(C9.ts, 0, 10)) + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types new file mode 100644 index 0000000000000..b5230006f1b78 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types @@ -0,0 +1,127 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +class C1 { +>C1 : C1 + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +class C2 { +>C2 : C2 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +class C3 { +>C3 : C3 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +class C4 { +>C4 : C4 + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +class C5 { +>C5 : C5 + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +class C6 { +>C6 : C6 + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +class C7 { +>C7 : C7 + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +class C8 { +>C8 : C8 + + g() { +>g : () => void + } + async * f() { +>f : () => AsyncIterableIterator + + this.g(); +>this.g() : void +>this.g : () => void +>this : this +>g : () => void + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +class B9 { +>B9 : B9 + + g() {} +>g : () => void +} +class C9 extends B9 { +>C9 : C9 +>B9 : B9 + + async * f() { +>f : () => AsyncIterableIterator + + super.g(); +>super.g() : void +>super.g : () => void +>super : B9 +>g : () => void + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js new file mode 100644 index 0000000000000..97df064bbe8f5 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js @@ -0,0 +1,166 @@ +//// [tests/cases/conformance/emitter/es2015/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2015.ts] //// + +//// [F1.ts] +async function * f1() { +} +//// [F2.ts] +async function * f2() { + const x = yield; +} +//// [F3.ts] +async function * f3() { + const x = yield 1; +} +//// [F4.ts] +async function * f4() { + const x = yield* [1]; +} +//// [F5.ts] +async function * f5() { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +async function * f6() { + const x = await 1; +} +//// [F7.ts] +async function * f7() { + return 1; +} + + +//// [F1.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f1() { + return __asyncGenerator(this, arguments, function* f1_1() { + }); +} +//// [F2.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f2() { + return __asyncGenerator(this, arguments, function* f2_1() { + const x = yield ["yield"]; + }); +} +//// [F3.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f3() { + return __asyncGenerator(this, arguments, function* f3_1() { + const x = yield ["yield", 1]; + }); +} +//// [F4.js] +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f4() { + return __asyncGenerator(this, arguments, function* f4_1() { + const x = yield* __asyncDelegator([1]); + }); +} +//// [F5.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +function f5() { + return __asyncGenerator(this, arguments, function* f5_1() { + const x = yield* __asyncDelegator((function () { return __asyncGenerator(this, arguments, function* () { yield ["yield", 1]; }); })()); + }); +} +//// [F6.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f6() { + return __asyncGenerator(this, arguments, function* f6_1() { + const x = yield ["await", 1]; + }); +} +//// [F7.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f7() { + return __asyncGenerator(this, arguments, function* f7_1() { + return 1; + }); +} diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.symbols new file mode 100644 index 0000000000000..8c2c8b1aead53 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts === +async function * f1() { +>f1 : Symbol(f1, Decl(F1.ts, 0, 0)) +} +=== tests/cases/conformance/emitter/es2015/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/es2015/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/es2015/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/es2015/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/es2015/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/es2015/asyncGenerators/F7.ts === +async function * f7() { +>f7 : Symbol(f7, Decl(F7.ts, 0, 0)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types new file mode 100644 index 0000000000000..5d57519d140ad --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types @@ -0,0 +1,61 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts === +async function * f1() { +>f1 : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F2.ts === +async function * f2() { +>f2 : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F3.ts === +async function * f3() { +>f3 : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F4.ts === +async function * f4() { +>f4 : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F5.ts === +async function * f5() { +>f5 : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F6.ts === +async function * f6() { +>f6 : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F7.ts === +async function * f7() { +>f7 : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js new file mode 100644 index 0000000000000..2a1b4393a9b89 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js @@ -0,0 +1,427 @@ +//// [tests/cases/conformance/emitter/es5/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es5.ts] //// + +//// [F1.ts] +async function * f1() { +} +//// [F2.ts] +async function * f2() { + const x = yield; +} +//// [F3.ts] +async function * f3() { + const x = yield 1; +} +//// [F4.ts] +async function * f4() { + const x = yield* [1]; +} +//// [F5.ts] +async function * f5() { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +async function * f6() { + const x = await 1; +} +//// [F7.ts] +async function * f7() { + return 1; +} + + +//// [F1.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f1() { + return __asyncGenerator(this, arguments, function f1_1() { + return __generator(this, function (_a) { + return [2 /*return*/]; + }); + }); +} +//// [F2.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f2() { + return __asyncGenerator(this, arguments, function f2_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield"]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +//// [F3.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f3() { + return __asyncGenerator(this, arguments, function f3_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +//// [F4.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +function f4() { + return __asyncGenerator(this, arguments, function f4_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator([1]))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +//// [F5.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +function f5() { + return __asyncGenerator(this, arguments, function f5_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator((function () { return __asyncGenerator(this, arguments, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); }); })()))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +//// [F6.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f6() { + return __asyncGenerator(this, arguments, function f6_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["await", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +//// [F7.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f7() { + return __asyncGenerator(this, arguments, function f7_1() { + return __generator(this, function (_a) { + return [2 /*return*/, 1]; + }); + }); +} diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.symbols new file mode 100644 index 0000000000000..416d53498115e --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts === +async function * f1() { +>f1 : Symbol(f1, Decl(F1.ts, 0, 0)) +} +=== tests/cases/conformance/emitter/es5/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/es5/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/es5/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/es5/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/es5/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/es5/asyncGenerators/F7.ts === +async function * f7() { +>f7 : Symbol(f7, Decl(F7.ts, 0, 0)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types new file mode 100644 index 0000000000000..2c3063eca5994 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types @@ -0,0 +1,61 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts === +async function * f1() { +>f1 : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F2.ts === +async function * f2() { +>f2 : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F3.ts === +async function * f3() { +>f3 : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F4.ts === +async function * f4() { +>f4 : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F5.ts === +async function * f5() { +>f5 : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F6.ts === +async function * f6() { +>f6 : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F7.ts === +async function * f7() { +>f7 : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js new file mode 100644 index 0000000000000..57708e027a361 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js @@ -0,0 +1,58 @@ +//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts] //// + +//// [F1.ts] +async function * f1() { +} +//// [F2.ts] +async function * f2() { + const x = yield; +} +//// [F3.ts] +async function * f3() { + const x = yield 1; +} +//// [F4.ts] +async function * f4() { + const x = yield* [1]; +} +//// [F5.ts] +async function * f5() { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +async function * f6() { + const x = await 1; +} +//// [F7.ts] +async function * f7() { + return 1; +} + + +//// [F1.js] +async function* f1() { +} +//// [F2.js] +async function* f2() { + const x = yield; +} +//// [F3.js] +async function* f3() { + const x = yield 1; +} +//// [F4.js] +async function* f4() { + const x = yield* [1]; +} +//// [F5.js] +async function* f5() { + const x = yield* (async function* () { yield 1; })(); +} +//// [F6.js] +async function* f6() { + const x = await 1; +} +//// [F7.js] +async function* f7() { + return 1; +} diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols new file mode 100644 index 0000000000000..018b7d7e07a64 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +async function * f1() { +>f1 : Symbol(f1, Decl(F1.ts, 0, 0)) +} +=== tests/cases/conformance/emitter/esnext/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 === +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 === +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 === +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 === +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 === +async function * f7() { +>f7 : Symbol(f7, Decl(F7.ts, 0, 0)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types new file mode 100644 index 0000000000000..5eb09901ac866 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types @@ -0,0 +1,61 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +async function * f1() { +>f1 : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +async function * f2() { +>f2 : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +async function * f3() { +>f3 : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +async function * f4() { +>f4 : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +async function * f5() { +>f5 : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +async function * f6() { +>f6 : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +async function * f7() { +>f7 : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js new file mode 100644 index 0000000000000..bc64f02928996 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js @@ -0,0 +1,166 @@ +//// [tests/cases/conformance/emitter/es2015/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2015.ts] //// + +//// [F1.ts] +const f1 = async function * () { +} +//// [F2.ts] +const f2 = async function * () { + const x = yield; +} +//// [F3.ts] +const f3 = async function * () { + const x = yield 1; +} +//// [F4.ts] +const f4 = async function * () { + const x = yield* [1]; +} +//// [F5.ts] +const f5 = async function * () { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +const f6 = async function * () { + const x = await 1; +} +//// [F7.ts] +const f7 = async function * () { + return 1; +} + + +//// [F1.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f1 = function () { + return __asyncGenerator(this, arguments, function* () { + }); +}; +//// [F2.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f2 = function () { + return __asyncGenerator(this, arguments, function* () { + const x = yield ["yield"]; + }); +}; +//// [F3.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f3 = function () { + return __asyncGenerator(this, arguments, function* () { + const x = yield ["yield", 1]; + }); +}; +//// [F4.js] +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f4 = function () { + return __asyncGenerator(this, arguments, function* () { + const x = yield* __asyncDelegator([1]); + }); +}; +//// [F5.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +const f5 = function () { + return __asyncGenerator(this, arguments, function* () { + const x = yield* __asyncDelegator((function () { return __asyncGenerator(this, arguments, function* () { yield ["yield", 1]; }); })()); + }); +}; +//// [F6.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f6 = function () { + return __asyncGenerator(this, arguments, function* () { + const x = yield ["await", 1]; + }); +}; +//// [F7.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const f7 = function () { + return __asyncGenerator(this, arguments, function* () { + return 1; + }); +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.symbols new file mode 100644 index 0000000000000..ff315c7f82ee8 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : Symbol(f1, Decl(F1.ts, 0, 5)) +} +=== tests/cases/conformance/emitter/es2015/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/es2015/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/es2015/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/es2015/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/es2015/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/es2015/asyncGenerators/F7.ts === +const f7 = async function * () { +>f7 : Symbol(f7, Decl(F7.ts, 0, 5)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types new file mode 100644 index 0000000000000..ab41ffd9c7126 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : () => AsyncIterableIterator +>async function * () {} : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F2.ts === +const f2 = async function * () { +>f2 : () => AsyncIterableIterator +>async function * () { const x = yield;} : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F3.ts === +const f3 = async function * () { +>f3 : () => AsyncIterableIterator<1> +>async function * () { const x = yield 1;} : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F4.ts === +const f4 = async function * () { +>f4 : () => AsyncIterableIterator +>async function * () { const x = yield* [1];} : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F5.ts === +const f5 = async function * () { +>f5 : () => AsyncIterableIterator<1> +>async function * () { const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F6.ts === +const f6 = async function * () { +>f6 : () => AsyncIterableIterator +>async function * () { const x = await 1;} : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/F7.ts === +const f7 = async function * () { +>f7 : () => AsyncIterableIterator +>async function * () { return 1;} : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js new file mode 100644 index 0000000000000..9593562987b99 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js @@ -0,0 +1,427 @@ +//// [tests/cases/conformance/emitter/es5/asyncGenerators/emitter.asyncGenerators.functionExpressions.es5.ts] //// + +//// [F1.ts] +const f1 = async function * () { +} +//// [F2.ts] +const f2 = async function * () { + const x = yield; +} +//// [F3.ts] +const f3 = async function * () { + const x = yield 1; +} +//// [F4.ts] +const f4 = async function * () { + const x = yield* [1]; +} +//// [F5.ts] +const f5 = async function * () { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +const f6 = async function * () { + const x = await 1; +} +//// [F7.ts] +const f7 = async function * () { + return 1; +} + + +//// [F1.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var f1 = function () { + return __asyncGenerator(this, arguments, function () { + return __generator(this, function (_a) { + return [2 /*return*/]; + }); + }); +}; +//// [F2.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var f2 = function () { + return __asyncGenerator(this, arguments, function () { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield"]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +}; +//// [F3.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var f3 = function () { + return __asyncGenerator(this, arguments, function () { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +}; +//// [F4.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var f4 = function () { + return __asyncGenerator(this, arguments, function () { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator([1]))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +}; +//// [F5.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var f5 = function () { + return __asyncGenerator(this, arguments, function () { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator((function () { return __asyncGenerator(this, arguments, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); }); })()))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +}; +//// [F6.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var f6 = function () { + return __asyncGenerator(this, arguments, function () { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["await", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +}; +//// [F7.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var f7 = function () { + return __asyncGenerator(this, arguments, function () { + return __generator(this, function (_a) { + return [2 /*return*/, 1]; + }); + }); +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.symbols new file mode 100644 index 0000000000000..88a9631c0bb6e --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : Symbol(f1, Decl(F1.ts, 0, 5)) +} +=== tests/cases/conformance/emitter/es5/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/es5/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/es5/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/es5/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/es5/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/es5/asyncGenerators/F7.ts === +const f7 = async function * () { +>f7 : Symbol(f7, Decl(F7.ts, 0, 5)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types new file mode 100644 index 0000000000000..424f09cf53b17 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : () => AsyncIterableIterator +>async function * () {} : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F2.ts === +const f2 = async function * () { +>f2 : () => AsyncIterableIterator +>async function * () { const x = yield;} : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F3.ts === +const f3 = async function * () { +>f3 : () => AsyncIterableIterator<1> +>async function * () { const x = yield 1;} : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F4.ts === +const f4 = async function * () { +>f4 : () => AsyncIterableIterator +>async function * () { const x = yield* [1];} : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F5.ts === +const f5 = async function * () { +>f5 : () => AsyncIterableIterator<1> +>async function * () { const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F6.ts === +const f6 = async function * () { +>f6 : () => AsyncIterableIterator +>async function * () { const x = await 1;} : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/F7.ts === +const f7 = async function * () { +>f7 : () => AsyncIterableIterator +>async function * () { return 1;} : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js new file mode 100644 index 0000000000000..349fea53b7a22 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js @@ -0,0 +1,58 @@ +//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts] //// + +//// [F1.ts] +const f1 = async function * () { +} +//// [F2.ts] +const f2 = async function * () { + const x = yield; +} +//// [F3.ts] +const f3 = async function * () { + const x = yield 1; +} +//// [F4.ts] +const f4 = async function * () { + const x = yield* [1]; +} +//// [F5.ts] +const f5 = async function * () { + const x = yield* (async function*() { yield 1; })(); +} +//// [F6.ts] +const f6 = async function * () { + const x = await 1; +} +//// [F7.ts] +const f7 = async function * () { + return 1; +} + + +//// [F1.js] +const f1 = async function* () { +}; +//// [F2.js] +const f2 = async function* () { + const x = yield; +}; +//// [F3.js] +const f3 = async function* () { + const x = yield 1; +}; +//// [F4.js] +const f4 = async function* () { + const x = yield* [1]; +}; +//// [F5.js] +const f5 = async function* () { + const x = yield* (async function* () { yield 1; })(); +}; +//// [F6.js] +const f6 = async function* () { + const x = await 1; +}; +//// [F7.js] +const f7 = async function* () { + return 1; +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols new file mode 100644 index 0000000000000..e59d8429fb735 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : Symbol(f1, Decl(F1.ts, 0, 5)) +} +=== tests/cases/conformance/emitter/esnext/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 === +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 === +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 === +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 === +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 === +const f7 = async function * () { +>f7 : Symbol(f7, Decl(F7.ts, 0, 5)) + + return 1; +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types new file mode 100644 index 0000000000000..e4559e3ecef25 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +const f1 = async function * () { +>f1 : () => AsyncIterableIterator +>async function * () {} : () => AsyncIterableIterator +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +const f2 = async function * () { +>f2 : () => AsyncIterableIterator +>async function * () { const x = yield;} : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +const f3 = async function * () { +>f3 : () => AsyncIterableIterator<1> +>async function * () { const x = yield 1;} : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +const f4 = async function * () { +>f4 : () => AsyncIterableIterator +>async function * () { const x = yield* [1];} : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +const f5 = async function * () { +>f5 : () => AsyncIterableIterator<1> +>async function * () { const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +const f6 = async function * () { +>f6 : () => AsyncIterableIterator +>async function * () { const x = await 1;} : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +const f7 = async function * () { +>f7 : () => AsyncIterableIterator +>async function * () { return 1;} : () => AsyncIterableIterator + + return 1; +>1 : 1 +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js new file mode 100644 index 0000000000000..3d3af24d0300a --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js @@ -0,0 +1,194 @@ +//// [tests/cases/conformance/emitter/es2015/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2015.ts] //// + +//// [O1.ts] +const o1 = { + async * f() { + } +} +//// [O2.ts] +const o2 = { + async * f() { + const x = yield; + } +} +//// [O3.ts] +const o3 = { + async * f() { + const x = yield 1; + } +} +//// [O4.ts] +const o4 = { + async * f() { + const x = yield* [1]; + } +} +//// [O5.ts] +const o5 = { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [O6.ts] +const o6 = { + async * f() { + const x = await 1; + } +} +//// [O7.ts] +const o7 = { + async * f() { + return 1; + } +} + + +//// [O1.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o1 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + }); + } +}; +//// [O2.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o2 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["yield"]; + }); + } +}; +//// [O3.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o3 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["yield", 1]; + }); + } +}; +//// [O4.js] +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o4 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield* __asyncDelegator([1]); + }); + } +}; +//// [O5.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +const o5 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield* __asyncDelegator((function () { return __asyncGenerator(this, arguments, function* () { yield ["yield", 1]; }); })()); + }); + } +}; +//// [O6.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o6 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + const x = yield ["await", 1]; + }); + } +}; +//// [O7.js] +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +const o7 = { + f() { + return __asyncGenerator(this, arguments, function* f_1() { + return 1; + }); + } +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.symbols b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.symbols new file mode 100644 index 0000000000000..7f03bf6eef0f3 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.symbols @@ -0,0 +1,74 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O1.ts === +const o1 = { +>o1 : Symbol(o1, Decl(O1.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O1.ts, 0, 12)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O2.ts === +const o2 = { +>o2 : Symbol(o2, Decl(O2.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O2.ts, 0, 12)) + + const x = yield; +>x : Symbol(x, Decl(O2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O3.ts === +const o3 = { +>o3 : Symbol(o3, Decl(O3.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O3.ts, 0, 12)) + + const x = yield 1; +>x : Symbol(x, Decl(O3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O4.ts === +const o4 = { +>o4 : Symbol(o4, Decl(O4.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O4.ts, 0, 12)) + + const x = yield* [1]; +>x : Symbol(x, Decl(O4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O5.ts === +const o5 = { +>o5 : Symbol(o5, Decl(O5.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O5.ts, 0, 12)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(O5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O6.ts === +const o6 = { +>o6 : Symbol(o6, Decl(O6.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O6.ts, 0, 12)) + + const x = await 1; +>x : Symbol(x, Decl(O6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O7.ts === +const o7 = { +>o7 : Symbol(o7, Decl(O7.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O7.ts, 0, 12)) + + return 1; + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types new file mode 100644 index 0000000000000..0e89d9a1ca6f0 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types @@ -0,0 +1,96 @@ +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O1.ts === +const o1 = { +>o1 : { f(): AsyncIterableIterator; } +>{ async * f() { }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O2.ts === +const o2 = { +>o2 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O3.ts === +const o3 = { +>o3 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield 1; }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O4.ts === +const o4 = { +>o4 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O5.ts === +const o5 = { +>o5 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield* (async function*() { yield 1; })(); }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O6.ts === +const o6 = { +>o6 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = await 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es2015/asyncGenerators/O7.ts === +const o7 = { +>o7 : { f(): AsyncIterableIterator; } +>{ async * f() { return 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js new file mode 100644 index 0000000000000..f819945f288b2 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js @@ -0,0 +1,455 @@ +//// [tests/cases/conformance/emitter/es5/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es5.ts] //// + +//// [O1.ts] +const o1 = { + async * f() { + } +} +//// [O2.ts] +const o2 = { + async * f() { + const x = yield; + } +} +//// [O3.ts] +const o3 = { + async * f() { + const x = yield 1; + } +} +//// [O4.ts] +const o4 = { + async * f() { + const x = yield* [1]; + } +} +//// [O5.ts] +const o5 = { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [O6.ts] +const o6 = { + async * f() { + const x = await 1; + } +} +//// [O7.ts] +const o7 = { + async * f() { + return 1; + } +} + + +//// [O1.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var o1 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + return [2 /*return*/]; + }); + }); + } +}; +//// [O2.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var o2 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield"]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } +}; +//// [O3.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var o3 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } +}; +//// [O4.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var o4 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator([1]))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } +}; +//// [O5.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }; + return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; } +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +var o5 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(__asyncDelegator((function () { return __asyncGenerator(this, arguments, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["yield", 1]]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); }); })()))]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } +}; +//// [O6.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var o6 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + var x; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, ["await", 1]]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } +}; +//// [O7.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +var o7 = { + f: function () { + return __asyncGenerator(this, arguments, function f_1() { + return __generator(this, function (_a) { + return [2 /*return*/, 1]; + }); + }); + } +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.symbols b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.symbols new file mode 100644 index 0000000000000..fbf789697424f --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.symbols @@ -0,0 +1,74 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/O1.ts === +const o1 = { +>o1 : Symbol(o1, Decl(O1.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O1.ts, 0, 12)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O2.ts === +const o2 = { +>o2 : Symbol(o2, Decl(O2.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O2.ts, 0, 12)) + + const x = yield; +>x : Symbol(x, Decl(O2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O3.ts === +const o3 = { +>o3 : Symbol(o3, Decl(O3.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O3.ts, 0, 12)) + + const x = yield 1; +>x : Symbol(x, Decl(O3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O4.ts === +const o4 = { +>o4 : Symbol(o4, Decl(O4.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O4.ts, 0, 12)) + + const x = yield* [1]; +>x : Symbol(x, Decl(O4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O5.ts === +const o5 = { +>o5 : Symbol(o5, Decl(O5.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O5.ts, 0, 12)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(O5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O6.ts === +const o6 = { +>o6 : Symbol(o6, Decl(O6.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O6.ts, 0, 12)) + + const x = await 1; +>x : Symbol(x, Decl(O6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O7.ts === +const o7 = { +>o7 : Symbol(o7, Decl(O7.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O7.ts, 0, 12)) + + return 1; + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types new file mode 100644 index 0000000000000..4c8ae47b6a2b1 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types @@ -0,0 +1,96 @@ +=== tests/cases/conformance/emitter/es5/asyncGenerators/O1.ts === +const o1 = { +>o1 : { f(): AsyncIterableIterator; } +>{ async * f() { }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O2.ts === +const o2 = { +>o2 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O3.ts === +const o3 = { +>o3 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield 1; }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O4.ts === +const o4 = { +>o4 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O5.ts === +const o5 = { +>o5 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield* (async function*() { yield 1; })(); }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O6.ts === +const o6 = { +>o6 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = await 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/es5/asyncGenerators/O7.ts === +const o7 = { +>o7 : { f(): AsyncIterableIterator; } +>{ async * f() { return 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js new file mode 100644 index 0000000000000..a1877b38184e0 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js @@ -0,0 +1,86 @@ +//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts] //// + +//// [O1.ts] +const o1 = { + async * f() { + } +} +//// [O2.ts] +const o2 = { + async * f() { + const x = yield; + } +} +//// [O3.ts] +const o3 = { + async * f() { + const x = yield 1; + } +} +//// [O4.ts] +const o4 = { + async * f() { + const x = yield* [1]; + } +} +//// [O5.ts] +const o5 = { + async * f() { + const x = yield* (async function*() { yield 1; })(); + } +} +//// [O6.ts] +const o6 = { + async * f() { + const x = await 1; + } +} +//// [O7.ts] +const o7 = { + async * f() { + return 1; + } +} + + +//// [O1.js] +const o1 = { + async *f() { + } +}; +//// [O2.js] +const o2 = { + async *f() { + const x = yield; + } +}; +//// [O3.js] +const o3 = { + async *f() { + const x = yield 1; + } +}; +//// [O4.js] +const o4 = { + async *f() { + const x = yield* [1]; + } +}; +//// [O5.js] +const o5 = { + async *f() { + const x = yield* (async function* () { yield 1; })(); + } +}; +//// [O6.js] +const o6 = { + async *f() { + const x = await 1; + } +}; +//// [O7.js] +const o7 = { + async *f() { + return 1; + } +}; diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols new file mode 100644 index 0000000000000..c1c7847c59279 --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols @@ -0,0 +1,74 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +const o1 = { +>o1 : Symbol(o1, Decl(O1.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O1.ts, 0, 12)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +const o2 = { +>o2 : Symbol(o2, Decl(O2.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O2.ts, 0, 12)) + + const x = yield; +>x : Symbol(x, Decl(O2.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +const o3 = { +>o3 : Symbol(o3, Decl(O3.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O3.ts, 0, 12)) + + const x = yield 1; +>x : Symbol(x, Decl(O3.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +const o4 = { +>o4 : Symbol(o4, Decl(O4.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O4.ts, 0, 12)) + + const x = yield* [1]; +>x : Symbol(x, Decl(O4.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +const o5 = { +>o5 : Symbol(o5, Decl(O5.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O5.ts, 0, 12)) + + const x = yield* (async function*() { yield 1; })(); +>x : Symbol(x, Decl(O5.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +const o6 = { +>o6 : Symbol(o6, Decl(O6.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O6.ts, 0, 12)) + + const x = await 1; +>x : Symbol(x, Decl(O6.ts, 2, 13)) + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +const o7 = { +>o7 : Symbol(o7, Decl(O7.ts, 0, 5)) + + async * f() { +>f : Symbol(f, Decl(O7.ts, 0, 12)) + + return 1; + } +} + diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types new file mode 100644 index 0000000000000..511cd7ec9e0bd --- /dev/null +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types @@ -0,0 +1,96 @@ +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +const o1 = { +>o1 : { f(): AsyncIterableIterator; } +>{ async * f() { }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +const o2 = { +>o2 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield; +>x : any +>yield : any + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +const o3 = { +>o3 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield 1; }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield 1; +>x : any +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +const o4 = { +>o4 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = yield* [1]; +>x : any +>yield* [1] : any +>[1] : number[] +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +const o5 = { +>o5 : { f(): AsyncIterableIterator<1>; } +>{ async * f() { const x = yield* (async function*() { yield 1; })(); }} : { f(): AsyncIterableIterator<1>; } + + async * f() { +>f : () => AsyncIterableIterator<1> + + const x = yield* (async function*() { yield 1; })(); +>x : any +>yield* (async function*() { yield 1; })() : any +>(async function*() { yield 1; })() : AsyncIterableIterator<1> +>(async function*() { yield 1; }) : () => AsyncIterableIterator<1> +>async function*() { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +const o6 = { +>o6 : { f(): AsyncIterableIterator; } +>{ async * f() { const x = await 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 + } +} +=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +const o7 = { +>o7 : { f(): AsyncIterableIterator; } +>{ async * f() { return 1; }} : { f(): AsyncIterableIterator; } + + async * f() { +>f : () => AsyncIterableIterator + + return 1; +>1 : 1 + } +} + diff --git a/tests/baselines/reference/emitter.forAwait.es2015.js b/tests/baselines/reference/emitter.forAwait.es2015.js new file mode 100644 index 0000000000000..bfd44581b82e2 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es2015.js @@ -0,0 +1,159 @@ +//// [tests/cases/conformance/emitter/es2015/forAwait/emitter.forAwait.es2015.ts] //// + +//// [file1.ts] +async function f1() { + let y: any; + for await (const x of y) { + } +} +//// [file2.ts] +async function f2() { + let x: any, y: any; + for await (x of y) { + } +} +//// [file3.ts] +async function* f3() { + let y: any; + for await (const x of y) { + } +} +//// [file4.ts] +async function* f4() { + let x: any, y: any; + for await (x of y) { + } +} + +//// [file1.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +function f1() { + return __awaiter(this, void 0, void 0, function* () { + let y; + try { + for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + const x = y_1_1.value; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + } + finally { if (e_1) throw e_1.error; } + } + var e_1, _a; + }); +} +//// [file2.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +function f2() { + return __awaiter(this, void 0, void 0, function* () { + let x, y; + try { + for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + x = y_1_1.value; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + } + finally { if (e_1) throw e_1.error; } + } + var e_1, _a; + }); +} +//// [file3.js] +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f3() { + return __asyncGenerator(this, arguments, function* f3_1() { + let y; + try { + for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + const x = y_1_1.value; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + } + finally { if (e_1) throw e_1.error; } + } + var e_1, _a; + }); +} +//// [file4.js] +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f4() { + return __asyncGenerator(this, arguments, function* f4_1() { + let x, y; + try { + for (var y_1 = __asyncValues(y), y_1_1 = yield ["await", y_1.next()]; !y_1_1.done; y_1_1 = yield ["await", y_1.next()]) { + x = y_1_1.value; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield ["await", _a.call(y_1)]; + } + finally { if (e_1) throw e_1.error; } + } + var e_1, _a; + }); +} diff --git a/tests/baselines/reference/emitter.forAwait.es2015.symbols b/tests/baselines/reference/emitter.forAwait.es2015.symbols new file mode 100644 index 0000000000000..6c4ed3b10e9a5 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es2015.symbols @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/es2015/forAwait/file1.ts === +async function f1() { +>f1 : Symbol(f1, Decl(file1.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file1.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file1.ts, 2, 20)) +>y : Symbol(y, Decl(file1.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file2.ts === +async function f2() { +>f2 : Symbol(f2, Decl(file2.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file3.ts === +async function* f3() { +>f3 : Symbol(f3, Decl(file3.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file3.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file3.ts, 2, 20)) +>y : Symbol(y, Decl(file3.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file4.ts === +async function* f4() { +>f4 : Symbol(f4, Decl(file4.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + } +} diff --git a/tests/baselines/reference/emitter.forAwait.es2015.types b/tests/baselines/reference/emitter.forAwait.es2015.types new file mode 100644 index 0000000000000..ac7321e43b459 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es2015.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/es2015/forAwait/file1.ts === +async function f1() { +>f1 : () => Promise + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file2.ts === +async function f2() { +>f2 : () => Promise + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file3.ts === +async function* f3() { +>f3 : () => AsyncIterableIterator + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es2015/forAwait/file4.ts === +async function* f4() { +>f4 : () => AsyncIterableIterator + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} diff --git a/tests/baselines/reference/emitter.forAwait.es5.js b/tests/baselines/reference/emitter.forAwait.es5.js new file mode 100644 index 0000000000000..5b904cf10a703 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es5.js @@ -0,0 +1,363 @@ +//// [tests/cases/conformance/emitter/es5/forAwait/emitter.forAwait.es5.ts] //// + +//// [file1.ts] +async function f1() { + let y: any; + for await (const x of y) { + } +} +//// [file2.ts] +async function f2() { + let x: any, y: any; + for await (x of y) { + } +} +//// [file3.ts] +async function* f3() { + let y: any; + for await (const x of y) { + } +} +//// [file4.ts] +async function* f4() { + let x: any, y: any; + for await (x of y) { + } +} + +//// [file1.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +function f1() { + return __awaiter(this, void 0, void 0, function () { + var y, y_1, y_1_1, x, _a, e_1, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 6, 7, 12]); + y_1 = __asyncValues(y); + return [4 /*yield*/, ["await", y_1.next()]]; + case 1: + y_1_1 = _c.sent(); + _c.label = 2; + case 2: + if (!!y_1_1.done) return [3 /*break*/, 5]; + x = y_1_1.value; + _c.label = 3; + case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 4: + y_1_1 = _c.sent(); + return [3 /*break*/, 2]; + case 5: return [3 /*break*/, 12]; + case 6: + _a = _c.sent(); + e_1 = { error: e_1_1 }; + return [3 /*break*/, 12]; + case 7: + _c.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _b.call(y_1)]]; + case 8: + _c.sent(); + _c.label = 9; + case 9: return [3 /*break*/, 11]; + case 10: + if (e_1) throw e_1.error; + return [7 /*endfinally*/]; + case 11: return [7 /*endfinally*/]; + case 12: return [2 /*return*/]; + } + }); + }); +} +//// [file2.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +function f2() { + return __awaiter(this, void 0, void 0, function () { + var x, y, y_1, y_1_1, _a, e_1, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 6, 7, 12]); + y_1 = __asyncValues(y); + return [4 /*yield*/, ["await", y_1.next()]]; + case 1: + y_1_1 = _c.sent(); + _c.label = 2; + case 2: + if (!!y_1_1.done) return [3 /*break*/, 5]; + x = y_1_1.value; + _c.label = 3; + case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 4: + y_1_1 = _c.sent(); + return [3 /*break*/, 2]; + case 5: return [3 /*break*/, 12]; + case 6: + _a = _c.sent(); + e_1 = { error: e_1_1 }; + return [3 /*break*/, 12]; + case 7: + _c.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _b.call(y_1)]]; + case 8: + _c.sent(); + _c.label = 9; + case 9: return [3 /*break*/, 11]; + case 10: + if (e_1) throw e_1.error; + return [7 /*endfinally*/]; + case 11: return [7 /*endfinally*/]; + case 12: return [2 /*return*/]; + } + }); + }); +} +//// [file3.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f3() { + return __asyncGenerator(this, arguments, function f3_1() { + var y, y_1, y_1_1, x, _a, e_1, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 6, 7, 12]); + y_1 = __asyncValues(y); + return [4 /*yield*/, ["await", y_1.next()]]; + case 1: + y_1_1 = _c.sent(); + _c.label = 2; + case 2: + if (!!y_1_1.done) return [3 /*break*/, 5]; + x = y_1_1.value; + _c.label = 3; + case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 4: + y_1_1 = _c.sent(); + return [3 /*break*/, 2]; + case 5: return [3 /*break*/, 12]; + case 6: + _a = _c.sent(); + e_1 = { error: e_1_1 }; + return [3 /*break*/, 12]; + case 7: + _c.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _b.call(y_1)]]; + case 8: + _c.sent(); + _c.label = 9; + case 9: return [3 /*break*/, 11]; + case 10: + if (e_1) throw e_1.error; + return [7 /*endfinally*/]; + case 11: return [7 /*endfinally*/]; + case 12: return [2 /*return*/]; + } + }); + }); +} +//// [file4.js] +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); +}; +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + var g = generator.apply(thisArg, _arguments || []), q = [], c, i; + return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; } + function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } } + function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); } + function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { c = void 0, f(v), next(); } +}; +function f4() { + return __asyncGenerator(this, arguments, function f4_1() { + var x, y, y_1, y_1_1, _a, e_1, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + _c.trys.push([0, 6, 7, 12]); + y_1 = __asyncValues(y); + return [4 /*yield*/, ["await", y_1.next()]]; + case 1: + y_1_1 = _c.sent(); + _c.label = 2; + case 2: + if (!!y_1_1.done) return [3 /*break*/, 5]; + x = y_1_1.value; + _c.label = 3; + case 3: return [4 /*yield*/, ["await", y_1.next()]]; + case 4: + y_1_1 = _c.sent(); + return [3 /*break*/, 2]; + case 5: return [3 /*break*/, 12]; + case 6: + _a = _c.sent(); + e_1 = { error: e_1_1 }; + return [3 /*break*/, 12]; + case 7: + _c.trys.push([7, , 10, 11]); + if (!(y_1_1 && !y_1_1.done && (_b = y_1.return))) return [3 /*break*/, 9]; + return [4 /*yield*/, ["await", _b.call(y_1)]]; + case 8: + _c.sent(); + _c.label = 9; + case 9: return [3 /*break*/, 11]; + case 10: + if (e_1) throw e_1.error; + return [7 /*endfinally*/]; + case 11: return [7 /*endfinally*/]; + case 12: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/emitter.forAwait.es5.symbols b/tests/baselines/reference/emitter.forAwait.es5.symbols new file mode 100644 index 0000000000000..40c5562453ce6 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es5.symbols @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/es5/forAwait/file1.ts === +async function f1() { +>f1 : Symbol(f1, Decl(file1.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file1.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file1.ts, 2, 20)) +>y : Symbol(y, Decl(file1.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file2.ts === +async function f2() { +>f2 : Symbol(f2, Decl(file2.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file3.ts === +async function* f3() { +>f3 : Symbol(f3, Decl(file3.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file3.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file3.ts, 2, 20)) +>y : Symbol(y, Decl(file3.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file4.ts === +async function* f4() { +>f4 : Symbol(f4, Decl(file4.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + } +} diff --git a/tests/baselines/reference/emitter.forAwait.es5.types b/tests/baselines/reference/emitter.forAwait.es5.types new file mode 100644 index 0000000000000..8c8f6dec723fb --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.es5.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/es5/forAwait/file1.ts === +async function f1() { +>f1 : () => Promise + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file2.ts === +async function f2() { +>f2 : () => Promise + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file3.ts === +async function* f3() { +>f3 : () => AsyncIterableIterator + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/es5/forAwait/file4.ts === +async function* f4() { +>f4 : () => AsyncIterableIterator + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} diff --git a/tests/baselines/reference/emitter.forAwait.esnext.js b/tests/baselines/reference/emitter.forAwait.esnext.js new file mode 100644 index 0000000000000..7a6c6837c9a2b --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.esnext.js @@ -0,0 +1,51 @@ +//// [tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts] //// + +//// [file1.ts] +async function f1() { + let y: any; + for await (const x of y) { + } +} +//// [file2.ts] +async function f2() { + let x: any, y: any; + for await (x of y) { + } +} +//// [file3.ts] +async function* f3() { + let y: any; + for await (const x of y) { + } +} +//// [file4.ts] +async function* f4() { + let x: any, y: any; + for await (x of y) { + } +} + +//// [file1.js] +async function f1() { + let y; + for await (const x of y) { + } +} +//// [file2.js] +async function f2() { + let x, y; + for await (x of y) { + } +} +//// [file3.js] +async function* f3() { + let y; + for await (const x of y) { + } +} +//// [file4.js] +async function* f4() { + let x, y; + for await (x of y) { + } +} diff --git a/tests/baselines/reference/emitter.forAwait.esnext.symbols b/tests/baselines/reference/emitter.forAwait.esnext.symbols new file mode 100644 index 0000000000000..137ebed08022d --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.esnext.symbols @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +async function f1() { +>f1 : Symbol(f1, Decl(file1.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file1.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file1.ts, 2, 20)) +>y : Symbol(y, Decl(file1.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +async function f2() { +>f2 : Symbol(f2, Decl(file2.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file2.ts, 1, 7)) +>y : Symbol(y, Decl(file2.ts, 1, 15)) + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +async function* f3() { +>f3 : Symbol(f3, Decl(file3.ts, 0, 0)) + + let y: any; +>y : Symbol(y, Decl(file3.ts, 1, 7)) + + for await (const x of y) { +>x : Symbol(x, Decl(file3.ts, 2, 20)) +>y : Symbol(y, Decl(file3.ts, 1, 7)) + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +async function* f4() { +>f4 : Symbol(f4, Decl(file4.ts, 0, 0)) + + let x: any, y: any; +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + + for await (x of y) { +>x : Symbol(x, Decl(file4.ts, 1, 7)) +>y : Symbol(y, Decl(file4.ts, 1, 15)) + } +} diff --git a/tests/baselines/reference/emitter.forAwait.esnext.types b/tests/baselines/reference/emitter.forAwait.esnext.types new file mode 100644 index 0000000000000..ae52bd1080de5 --- /dev/null +++ b/tests/baselines/reference/emitter.forAwait.esnext.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +async function f1() { +>f1 : () => Promise + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +async function f2() { +>f2 : () => Promise + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +async function* f3() { +>f3 : () => AsyncIterableIterator + + let y: any; +>y : any + + for await (const x of y) { +>x : any +>y : any + } +} +=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +async function* f4() { +>f4 : () => AsyncIterableIterator + + let x: any, y: any; +>x : any +>y : any + + for await (x of y) { +>x : any +>y : any + } +} diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js new file mode 100644 index 0000000000000..7123841025ffd --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.js @@ -0,0 +1,15 @@ +//// [emptyAssignmentPatterns01_ES5iterable.ts] + +var a: any; + +({} = a); +([] = a); + +//// [emptyAssignmentPatterns01_ES5iterable.js] +var a; +(a); +(a); + + +//// [emptyAssignmentPatterns01_ES5iterable.d.ts] +declare var a: any; diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols new file mode 100644 index 0000000000000..8811c61dd9e0d --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === + +var a: any; +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) + +({} = a); +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) + +([] = a); +>a : Symbol(a, Decl(emptyAssignmentPatterns01_ES5iterable.ts, 1, 3)) + diff --git a/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types new file mode 100644 index 0000000000000..4a5e17d7cdefa --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns01_ES5iterable.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns01_ES5iterable.ts === + +var a: any; +>a : any + +({} = a); +>({} = a) : any +>{} = a : any +>{} : {} +>a : any + +([] = a); +>([] = a) : any +>[] = a : any +>[] : undefined[] +>a : any + diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js new file mode 100644 index 0000000000000..45cd426549e58 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.js @@ -0,0 +1,35 @@ +//// [emptyAssignmentPatterns02_ES5iterable.ts] + +var a: any; +let x, y, z, a1, a2, a3; + +({} = { x, y, z } = a); +([] = [ a1, a2, a3] = a); + +//// [emptyAssignmentPatterns02_ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var a; +var x, y, z, a1, a2, a3; +(x = a.x, y = a.y, z = a.z); +(_a = __read(a, 3), a1 = _a[0], a2 = _a[1], a3 = _a[2]); +var _a; + + +//// [emptyAssignmentPatterns02_ES5iterable.d.ts] +declare var a: any; +declare let x: any, y: any, z: any, a1: any, a2: any, a3: any; diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols new file mode 100644 index 0000000000000..fc90df74d1d50 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.symbols @@ -0,0 +1,25 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === + +var a: any; +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) + +let x, y, z, a1, a2, a3; +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) + +({} = { x, y, z } = a); +>x : Symbol(x, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 7)) +>y : Symbol(y, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 10)) +>z : Symbol(z, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 4, 13)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) + +([] = [ a1, a2, a3] = a); +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 2, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns02_ES5iterable.ts, 1, 3)) + diff --git a/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types new file mode 100644 index 0000000000000..5f19cd98ec48a --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns02_ES5iterable.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns02_ES5iterable.ts === + +var a: any; +>a : any + +let x, y, z, a1, a2, a3; +>x : any +>y : any +>z : any +>a1 : any +>a2 : any +>a3 : any + +({} = { x, y, z } = a); +>({} = { x, y, z } = a) : any +>{} = { x, y, z } = a : any +>{} : {} +>{ x, y, z } = a : any +>{ x, y, z } : { x: any; y: any; z: any; } +>x : any +>y : any +>z : any +>a : any + +([] = [ a1, a2, a3] = a); +>([] = [ a1, a2, a3] = a) : any +>[] = [ a1, a2, a3] = a : any +>[] : undefined[] +>[ a1, a2, a3] = a : any +>[ a1, a2, a3] : [any, any, any] +>a1 : any +>a2 : any +>a3 : any +>a : any + diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js new file mode 100644 index 0000000000000..79806e5994d1e --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.js @@ -0,0 +1,15 @@ +//// [emptyAssignmentPatterns03_ES5iterable.ts] + +var a: any; + +({} = {} = a); +([] = [] = a); + +//// [emptyAssignmentPatterns03_ES5iterable.js] +var a; +(a); +(a); + + +//// [emptyAssignmentPatterns03_ES5iterable.d.ts] +declare var a: any; diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols new file mode 100644 index 0000000000000..e1ac0ea4c5c53 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === + +var a: any; +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) + +({} = {} = a); +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) + +([] = [] = a); +>a : Symbol(a, Decl(emptyAssignmentPatterns03_ES5iterable.ts, 1, 3)) + diff --git a/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types new file mode 100644 index 0000000000000..273d360d92f25 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns03_ES5iterable.types @@ -0,0 +1,21 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns03_ES5iterable.ts === + +var a: any; +>a : any + +({} = {} = a); +>({} = {} = a) : any +>{} = {} = a : any +>{} : {} +>{} = a : any +>{} : {} +>a : any + +([] = [] = a); +>([] = [] = a) : any +>[] = [] = a : any +>[] : undefined[] +>[] = a : any +>[] : undefined[] +>a : any + diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js new file mode 100644 index 0000000000000..5cb4a63b03d09 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.js @@ -0,0 +1,35 @@ +//// [emptyAssignmentPatterns04_ES5iterable.ts] + +var a: any; +let x, y, z, a1, a2, a3; + +({ x, y, z } = {} = a); +([ a1, a2, a3] = [] = a); + +//// [emptyAssignmentPatterns04_ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var a; +var x, y, z, a1, a2, a3; +(x = a.x, y = a.y, z = a.z); +(_a = __read(a, 3), a1 = _a[0], a2 = _a[1], a3 = _a[2]); +var _a; + + +//// [emptyAssignmentPatterns04_ES5iterable.d.ts] +declare var a: any; +declare let x: any, y: any, z: any, a1: any, a2: any, a3: any; diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols new file mode 100644 index 0000000000000..d433a0f125cbc --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.symbols @@ -0,0 +1,25 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === + +var a: any; +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) + +let x, y, z, a1, a2, a3; +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 3)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 6)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 9)) +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) + +({ x, y, z } = {} = a); +>x : Symbol(x, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 2)) +>y : Symbol(y, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 5)) +>z : Symbol(z, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 4, 8)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) + +([ a1, a2, a3] = [] = a); +>a1 : Symbol(a1, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 12)) +>a2 : Symbol(a2, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 16)) +>a3 : Symbol(a3, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 2, 20)) +>a : Symbol(a, Decl(emptyAssignmentPatterns04_ES5iterable.ts, 1, 3)) + diff --git a/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types new file mode 100644 index 0000000000000..c926ec31bfa28 --- /dev/null +++ b/tests/baselines/reference/emptyAssignmentPatterns04_ES5iterable.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/es6/destructuring/emptyAssignmentPatterns04_ES5iterable.ts === + +var a: any; +>a : any + +let x, y, z, a1, a2, a3; +>x : any +>y : any +>z : any +>a1 : any +>a2 : any +>a3 : any + +({ x, y, z } = {} = a); +>({ x, y, z } = {} = a) : any +>{ x, y, z } = {} = a : any +>{ x, y, z } : { x: any; y: any; z: any; } +>x : any +>y : any +>z : any +>{} = a : any +>{} : {} +>a : any + +([ a1, a2, a3] = [] = a); +>([ a1, a2, a3] = [] = a) : any +>[ a1, a2, a3] = [] = a : any +>[ a1, a2, a3] : [any, any, any] +>a1 : any +>a2 : any +>a3 : any +>[] = a : any +>[] : undefined[] +>a : any + diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js new file mode 100644 index 0000000000000..c4eeb9994e698 --- /dev/null +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.js @@ -0,0 +1,182 @@ +//// [emptyVariableDeclarationBindingPatterns01_ES5iterable.ts] + +(function () { + var a: any; + + var {} = a; + let {} = a; + const {} = a; + + var [] = a; + let [] = a; + const [] = a; + + var {} = a, [] = a; + let {} = a, [] = a; + const {} = a, [] = a; + + var { p1: {}, p2: [] } = a; + let { p1: {}, p2: [] } = a; + const { p1: {}, p2: [] } = a; + + for (var {} = {}, {} = {}; false; void 0) { + } + + function f({} = a, [] = a, { p: {} = a} = a) { + return ({} = a, [] = a, { p: {} = a } = a) => a; + } +})(); + +(function () { + const ns: number[][] = []; + + for (var {} of ns) { + } + + for (let {} of ns) { + } + + for (const {} of ns) { + } + + for (var [] of ns) { + } + + for (let [] of ns) { + } + + for (const [] of ns) { + } +})(); + +//// [emptyVariableDeclarationBindingPatterns01_ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __values = (this && this.__values) || function (o) { + var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; + if (m) return m.call(o); + return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; +}; +(function () { + var a; + var _a = a; + var _b = a; + var _c = a; + var _d = __read(a, 0); + var _e = __read(a, 0); + var _f = __read(a, 0); + var _g = a, _h = __read(a, 0); + var _j = a, _k = __read(a, 0); + var _l = a, _m = __read(a, 0); + var _o = a.p1, _p = __read(a.p2, 0); + var _q = a.p1, _r = __read(a.p2, 0); + var _s = a.p1, _t = __read(a.p2, 0); + for (var _u = {}, _v = {}; false; void 0) { + } + function f(_a, _b, _c) { + _a = a; + _b = a; + var _d = (_c === void 0 ? a : _c).p, _e = _d === void 0 ? a : _d; + return function (_a, _b, _c) { + _a = a; + _b = a; + var _d = (_c === void 0 ? a : _c).p, _e = _d === void 0 ? a : _d; + return a; + }; + } +})(); +(function () { + var ns = []; + try { + for (var ns_1 = __values(ns), ns_1_1 = ns_1.next(); !ns_1_1.done; ns_1_1 = ns_1.next()) { + var _a = ns_1_1.value; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (ns_1_1 && !ns_1_1.done && (_b = ns_1.return)) _b.call(ns_1); + } + finally { if (e_1) throw e_1.error; } + } + try { + for (var ns_2 = __values(ns), ns_2_1 = ns_2.next(); !ns_2_1.done; ns_2_1 = ns_2.next()) { + var _c = ns_2_1.value; + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (ns_2_1 && !ns_2_1.done && (_d = ns_2.return)) _d.call(ns_2); + } + finally { if (e_2) throw e_2.error; } + } + try { + for (var ns_3 = __values(ns), ns_3_1 = ns_3.next(); !ns_3_1.done; ns_3_1 = ns_3.next()) { + var _e = ns_3_1.value; + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (ns_3_1 && !ns_3_1.done && (_f = ns_3.return)) _f.call(ns_3); + } + finally { if (e_3) throw e_3.error; } + } + try { + for (var ns_4 = __values(ns), ns_4_1 = ns_4.next(); !ns_4_1.done; ns_4_1 = ns_4.next()) { + var _g = __read(ns_4_1.value, 0); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (ns_4_1 && !ns_4_1.done && (_h = ns_4.return)) _h.call(ns_4); + } + finally { if (e_4) throw e_4.error; } + } + try { + for (var ns_5 = __values(ns), ns_5_1 = ns_5.next(); !ns_5_1.done; ns_5_1 = ns_5.next()) { + var _j = __read(ns_5_1.value, 0); + } + } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (ns_5_1 && !ns_5_1.done && (_k = ns_5.return)) _k.call(ns_5); + } + finally { if (e_5) throw e_5.error; } + } + try { + for (var ns_6 = __values(ns), ns_6_1 = ns_6.next(); !ns_6_1.done; ns_6_1 = ns_6.next()) { + var _l = __read(ns_6_1.value, 0); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (ns_6_1 && !ns_6_1.done && (_m = ns_6.return)) _m.call(ns_6); + } + finally { if (e_6) throw e_6.error; } + } + var e_1, _b, e_2, _d, e_3, _f, e_4, _h, e_5, _k, e_6, _m; +})(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols new file mode 100644 index 0000000000000..d77525cf7678a --- /dev/null +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.symbols @@ -0,0 +1,92 @@ +=== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === + +(function () { + var a: any; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + var {} = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + let {} = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + const {} = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + var [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + let [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + const [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + var {} = a, [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + let {} = a, [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + const {} = a, [] = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + var { p1: {}, p2: [] } = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + let { p1: {}, p2: [] } = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + const { p1: {}, p2: [] } = a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + for (var {} = {}, {} = {}; false; void 0) { + } + + function f({} = a, [] = a, { p: {} = a} = a) { +>f : Symbol(f, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 21, 5)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + + return ({} = a, [] = a, { p: {} = a } = a) => a; +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) +>a : Symbol(a, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 2, 7)) + } +})(); + +(function () { + const ns: number[][] = []; +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + + for (var {} of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } + + for (let {} of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } + + for (const {} of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } + + for (var [] of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } + + for (let [] of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } + + for (const [] of ns) { +>ns : Symbol(ns, Decl(emptyVariableDeclarationBindingPatterns01_ES5iterable.ts, 29, 9)) + } +})(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types new file mode 100644 index 0000000000000..591b149ac075b --- /dev/null +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5iterable.types @@ -0,0 +1,115 @@ +=== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns01_ES5iterable.ts === + +(function () { +>(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }})() : void +>(function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }}) : () => void +>function () { var a: any; var {} = a; let {} = a; const {} = a; var [] = a; let [] = a; const [] = a; var {} = a, [] = a; let {} = a, [] = a; const {} = a, [] = a; var { p1: {}, p2: [] } = a; let { p1: {}, p2: [] } = a; const { p1: {}, p2: [] } = a; for (var {} = {}, {} = {}; false; void 0) { } function f({} = a, [] = a, { p: {} = a} = a) { return ({} = a, [] = a, { p: {} = a } = a) => a; }} : () => void + + var a: any; +>a : any + + var {} = a; +>a : any + + let {} = a; +>a : any + + const {} = a; +>a : any + + var [] = a; +>a : any + + let [] = a; +>a : any + + const [] = a; +>a : any + + var {} = a, [] = a; +>a : any +>a : any + + let {} = a, [] = a; +>a : any +>a : any + + const {} = a, [] = a; +>a : any +>a : any + + var { p1: {}, p2: [] } = a; +>p1 : any +>p2 : any +>a : any + + let { p1: {}, p2: [] } = a; +>p1 : any +>p2 : any +>a : any + + const { p1: {}, p2: [] } = a; +>p1 : any +>p2 : any +>a : any + + for (var {} = {}, {} = {}; false; void 0) { +>{} : {} +>{} : {} +>false : false +>void 0 : undefined +>0 : 0 + } + + function f({} = a, [] = a, { p: {} = a} = a) { +>f : ({}?: any, []?: any, {p: {}}?: any) => ({}?: any, []?: any, {p: {}}?: any) => any +>a : any +>a : any +>p : any +>a : any +>a : any + + return ({} = a, [] = a, { p: {} = a } = a) => a; +>({} = a, [] = a, { p: {} = a } = a) => a : ({}?: any, []?: any, {p: {}}?: any) => any +>a : any +>a : any +>p : any +>a : any +>a : any +>a : any + } +})(); + +(function () { +>(function () { const ns: number[][] = []; for (var {} of ns) { } for (let {} of ns) { } for (const {} of ns) { } for (var [] of ns) { } for (let [] of ns) { } for (const [] of ns) { }})() : void +>(function () { const ns: number[][] = []; for (var {} of ns) { } for (let {} of ns) { } for (const {} of ns) { } for (var [] of ns) { } for (let [] of ns) { } for (const [] of ns) { }}) : () => void +>function () { const ns: number[][] = []; for (var {} of ns) { } for (let {} of ns) { } for (const {} of ns) { } for (var [] of ns) { } for (let [] of ns) { } for (const [] of ns) { }} : () => void + + const ns: number[][] = []; +>ns : number[][] +>[] : undefined[] + + for (var {} of ns) { +>ns : number[][] + } + + for (let {} of ns) { +>ns : number[][] + } + + for (const {} of ns) { +>ns : number[][] + } + + for (var [] of ns) { +>ns : number[][] + } + + for (let [] of ns) { +>ns : number[][] + } + + for (const [] of ns) { +>ns : number[][] + } +})(); diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt new file mode 100644 index 0000000000000..453f44be10c9e --- /dev/null +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.errors.txt @@ -0,0 +1,31 @@ +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(3,9): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(4,9): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(5,11): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(7,9): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(8,9): error TS1182: A destructuring declaration must have an initializer. +tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts(9,11): error TS1182: A destructuring declaration must have an initializer. + + +==== tests/cases/conformance/es6/destructuring/emptyVariableDeclarationBindingPatterns02_ES5iterable.ts (6 errors) ==== + + (function () { + var {}; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + let {}; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + const {}; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + + var []; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + let []; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + const []; + ~~ +!!! error TS1182: A destructuring declaration must have an initializer. + })(); \ No newline at end of file diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js new file mode 100644 index 0000000000000..b5457d0a2ece0 --- /dev/null +++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.js @@ -0,0 +1,40 @@ +//// [emptyVariableDeclarationBindingPatterns02_ES5iterable.ts] + +(function () { + var {}; + let {}; + const {}; + + var []; + let []; + const []; +})(); + +//// [emptyVariableDeclarationBindingPatterns02_ES5iterable.js] +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +(function () { + var _a = void 0; + var _b = void 0; + var _c = void 0; + var _d = __read(void 0, 0); + var _e = __read(void 0, 0); + var _f = __read(void 0, 0); +})(); + + +//// [emptyVariableDeclarationBindingPatterns02_ES5iterable.d.ts] diff --git a/tests/baselines/reference/es5-asyncFunction.js b/tests/baselines/reference/es5-asyncFunction.js index 6f04c7ed7efb3..21bd517adc255 100644 --- a/tests/baselines/reference/es5-asyncFunction.js +++ b/tests/baselines/reference/es5-asyncFunction.js @@ -18,8 +18,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js index c8a4733aa94f6..d3f570d5882f8 100644 --- a/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js +++ b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js @@ -36,12 +36,11 @@ async function arrayLiteral7() { //// [es5-asyncFunctionArrayLiterals.js] function arrayLiteral0() { return __awaiter(this, void 0, void 0, function () { - var _a; - return __generator(this, function (_b) { - switch (_b.label) { + return __generator(this, function (_a) { + switch (_a.label) { case 0: return [4 /*yield*/, y]; case 1: - x = [_b.sent(), z]; + x = [_a.sent(), z]; return [2 /*return*/]; } }); @@ -76,14 +75,14 @@ function arrayLiteral2() { } function arrayLiteral3() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d; - return __generator(this, function (_e) { - switch (_e.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = y).concat; return [4 /*yield*/, z]; case 1: - x = _b.apply(_a, [[_e.sent()]]); + x = _b.apply(_a, [[_c.sent()]]); return [2 /*return*/]; } }); @@ -91,12 +90,11 @@ function arrayLiteral3() { } function arrayLiteral4() { return __awaiter(this, void 0, void 0, function () { - var _a; - return __generator(this, function (_b) { - switch (_b.label) { + return __generator(this, function (_a) { + switch (_a.label) { case 0: return [4 /*yield*/, y]; case 1: - x = [_b.sent()].concat(z); + x = [_a.sent()].concat(z); return [2 /*return*/]; } }); @@ -104,14 +102,14 @@ function arrayLiteral4() { } function arrayLiteral5() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = [y]).concat; return [4 /*yield*/, z]; case 1: - x = _b.apply(_a, [(_d.sent())]); + x = _b.apply(_a, [(_c.sent())]); return [2 /*return*/]; } }); diff --git a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js index 23a79cef34308..809f6254f0838 100644 --- a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js +++ b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js @@ -518,19 +518,19 @@ function binaryCompoundAssignment8() { } function binaryExponentiation() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f; - return __generator(this, function (_g) { - switch (_g.label) { + var _a, _b, _c, _d, _e; + return __generator(this, function (_f) { + switch (_f.label) { case 0: _b = (_a = Math).pow; return [4 /*yield*/, x]; case 1: - _b.apply(_a, [(_g.sent()), y]); - _e = (_d = Math).pow; - _f = [x]; + _b.apply(_a, [(_f.sent()), y]); + _d = (_c = Math).pow; + _e = [x]; return [4 /*yield*/, y]; case 2: - _e.apply(_d, _f.concat([_g.sent()])); + _d.apply(_c, _e.concat([_f.sent()])); return [2 /*return*/]; } }); diff --git a/tests/baselines/reference/es5-asyncFunctionCallExpressions.js b/tests/baselines/reference/es5-asyncFunctionCallExpressions.js index 93c4dcfd3cbc9..452a5e1cc9018 100644 --- a/tests/baselines/reference/es5-asyncFunctionCallExpressions.js +++ b/tests/baselines/reference/es5-asyncFunctionCallExpressions.js @@ -113,14 +113,14 @@ function callExpression1() { } function callExpression2() { return __awaiter(this, void 0, void 0, function () { - var _a, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: _a = x; return [4 /*yield*/, y]; case 1: - _a.apply(void 0, [_c.sent(), z]); + _a.apply(void 0, [_b.sent(), z]); return [2 /*return*/]; } }); @@ -184,16 +184,16 @@ function callExpression6() { } function callExpression7() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f, _g; - return __generator(this, function (_h) { - switch (_h.label) { + var _a, _b, _c, _d, _e; + return __generator(this, function (_f) { + switch (_f.label) { case 0: _b = (_a = x).apply; _c = [void 0]; _e = (_d = y).concat; return [4 /*yield*/, z]; case 1: - _b.apply(_a, _c.concat([_e.apply(_d, [[_h.sent()]])])); + _b.apply(_a, _c.concat([_e.apply(_d, [[_f.sent()]])])); return [2 /*return*/]; } }); @@ -201,15 +201,15 @@ function callExpression7() { } function callExpression8() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d; - return __generator(this, function (_e) { - switch (_e.label) { + var _a, _b, _c; + return __generator(this, function (_d) { + switch (_d.label) { case 0: _b = (_a = x).apply; _c = [void 0]; return [4 /*yield*/, y]; case 1: - _b.apply(_a, _c.concat([[_e.sent()].concat(z)])); + _b.apply(_a, _c.concat([[_d.sent()].concat(z)])); return [2 /*return*/]; } }); @@ -217,16 +217,16 @@ function callExpression8() { } function callExpression9() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f; - return __generator(this, function (_g) { - switch (_g.label) { + var _a, _b, _c, _d, _e; + return __generator(this, function (_f) { + switch (_f.label) { case 0: _b = (_a = x).apply; _c = [void 0]; _e = (_d = [y]).concat; return [4 /*yield*/, z]; case 1: - _b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent())])])); + _b.apply(_a, _c.concat([_e.apply(_d, [(_f.sent())])])); return [2 /*return*/]; } }); @@ -270,14 +270,14 @@ function callExpression12() { } function callExpression13() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = x).a; return [4 /*yield*/, y]; case 1: - _b.apply(_a, [_d.sent(), z]); + _b.apply(_a, [_c.sent(), z]); return [2 /*return*/]; } }); @@ -352,14 +352,14 @@ function callExpression18() { } function callExpression19() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = x)[a]; return [4 /*yield*/, y]; case 1: - _b.apply(_a, [_d.sent(), z]); + _b.apply(_a, [_c.sent(), z]); return [2 /*return*/]; } }); diff --git a/tests/baselines/reference/es5-asyncFunctionNewExpressions.js b/tests/baselines/reference/es5-asyncFunctionNewExpressions.js index 0fb1140f129dc..ba1331afd205a 100644 --- a/tests/baselines/reference/es5-asyncFunctionNewExpressions.js +++ b/tests/baselines/reference/es5-asyncFunctionNewExpressions.js @@ -112,14 +112,14 @@ function newExpression1() { } function newExpression2() { return __awaiter(this, void 0, void 0, function () { - var _a, _b; - return __generator(this, function (_c) { - switch (_c.label) { + var _a; + return __generator(this, function (_b) { + switch (_b.label) { case 0: _a = x.bind; return [4 /*yield*/, y]; case 1: - new (_a.apply(x, [void 0, _c.sent(), z]))(); + new (_a.apply(x, [void 0, _b.sent(), z]))(); return [2 /*return*/]; } }); @@ -168,16 +168,16 @@ function newExpression5() { } function newExpression6() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f; - return __generator(this, function (_g) { - switch (_g.label) { + var _a, _b, _c, _d, _e; + return __generator(this, function (_f) { + switch (_f.label) { case 0: _b = (_a = x.bind).apply; _c = [x]; _e = (_d = [void 0]).concat; return [4 /*yield*/, y]; case 1: - new (_b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent()), [z]])])))(); + new (_b.apply(_a, _c.concat([_e.apply(_d, [(_f.sent()), [z]])])))(); return [2 /*return*/]; } }); @@ -185,9 +185,9 @@ function newExpression6() { } function newExpression7() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f, _g; - return __generator(this, function (_h) { - switch (_h.label) { + var _a, _b, _c, _d, _e, _f; + return __generator(this, function (_g) { + switch (_g.label) { case 0: _b = (_a = x.bind).apply; _c = [x]; @@ -195,7 +195,7 @@ function newExpression7() { _f = [y]; return [4 /*yield*/, z]; case 1: - new (_b.apply(_a, _c.concat([_e.apply(_d, _f.concat([[_h.sent()]]))])))(); + new (_b.apply(_a, _c.concat([_e.apply(_d, _f.concat([[_g.sent()]]))])))(); return [2 /*return*/]; } }); @@ -220,16 +220,16 @@ function newExpression8() { } function newExpression9() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c, _d, _e, _f; - return __generator(this, function (_g) { - switch (_g.label) { + var _a, _b, _c, _d, _e; + return __generator(this, function (_f) { + switch (_f.label) { case 0: _b = (_a = x.bind).apply; _c = [x]; _e = (_d = [void 0, y]).concat; return [4 /*yield*/, z]; case 1: - new (_b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent())])])))(); + new (_b.apply(_a, _c.concat([_e.apply(_d, [(_f.sent())])])))(); return [2 /*return*/]; } }); @@ -273,14 +273,14 @@ function newExpression12() { } function newExpression13() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = x.a).bind; return [4 /*yield*/, y]; case 1: - new (_b.apply(_a, [void 0, _d.sent(), z]))(); + new (_b.apply(_a, [void 0, _c.sent(), z]))(); return [2 /*return*/]; } }); @@ -355,14 +355,14 @@ function newExpression18() { } function newExpression19() { return __awaiter(this, void 0, void 0, function () { - var _a, _b, _c; - return __generator(this, function (_d) { - switch (_d.label) { + var _a, _b; + return __generator(this, function (_c) { + switch (_c.label) { case 0: _b = (_a = x[a]).bind; return [4 /*yield*/, y]; case 1: - new (_b.apply(_a, [void 0, _d.sent(), z]))(); + new (_b.apply(_a, [void 0, _c.sent(), z]))(); return [2 /*return*/]; } }); diff --git a/tests/baselines/reference/es5-importHelpersAsyncFunctions.js b/tests/baselines/reference/es5-importHelpersAsyncFunctions.js index f62c861b7c99e..9e5b63b23e97b 100644 --- a/tests/baselines/reference/es5-importHelpersAsyncFunctions.js +++ b/tests/baselines/reference/es5-importHelpersAsyncFunctions.js @@ -39,8 +39,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt new file mode 100644 index 0000000000000..febd6d1160e0c --- /dev/null +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt @@ -0,0 +1,235 @@ +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/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== + class C1 { + async * f() { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== + class C2 { + async * await() { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== + class C3 { + async * yield() { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== + class C4 { + async * f(await) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2693: 'await' only refers to a type, but is being used as a value here. + ~ +!!! error TS1005: ';' expected. + } + } + ~ +!!! error TS1128: Declaration or statement expected. +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== + class C5 { + async * f(yield) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2693: 'yield' only refers to a type, but is being used as a value here. + ~ +!!! error TS1005: ';' expected. + } + } + ~ +!!! error TS1128: Declaration or statement expected. +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + class C7 { + async * f(a = yield) { + ~~~~~ +!!! error TS1163: A 'yield' expression is only allowed in a generator body. + ~~~~~ +!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== + class C8 { + async * f() { + async function * g() { + } + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== + class C9 { + async * f() { + function yield() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '=>' expected. + } + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== + class C10 { + async * f() { + const x = function yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=>' expected. + }; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== + class C11 { + async * f() { + function await() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + } + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== + class C12 { + async * f() { + const x = function await() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + }; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== + class C13 { + async * f() { + yield; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== + class C14 { + async * f() { + yield 1; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== + class C15 { + async * f() { + yield *; + ~ +!!! error TS1109: Expression expected. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== + class C16 { + async * f() { + yield * []; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== + class C17 { + async * f() { + await 1; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== + class C18 { + async * f() { + await; + ~ +!!! error TS1109: Expression expected. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== + interface await {} + class C19 { + async * f() { + let x: await; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts (1 errors) ==== + interface yield {} + class C20 { + async * f() { + let x: yield; + ~~~~~ +!!! 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) ==== + class C21 { + async * [yield]() { + ~~~~~ +!!! error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. + ~~~~~ +!!! 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) ==== + class C22 { + async * f() { + const x = { [yield]: 1 }; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== + class C23 { + async * get x() { + ~ +!!! error TS1005: '(' expected. + return 1; + } + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + class C25 { + async * x = 1; + ~ +!!! error TS1005: '(' expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt new file mode 100644 index 0000000000000..a80c67badd5e3 --- /dev/null +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt @@ -0,0 +1,137 @@ +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/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts (0 errors) ==== + async function * f1() { + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts (0 errors) ==== + async function * await() { + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts (0 errors) ==== + async function * yield() { + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + async function * f5(yield) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~ +!!! error TS1005: ';' expected. + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + 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) ==== + async function * f8() { + async function * g() { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== + async function * f9() { + function yield() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '=>' expected. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== + async function * f10() { + const x = function yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=>' expected. + }; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== + async function * f11() { + function await() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (2 errors) ==== + async function * f12() { + const x = function yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=>' expected. + }; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== + async function * f13() { + yield; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== + async function * f14() { + yield 1; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== + async function * f15() { + yield *; + ~ +!!! error TS1109: Expression expected. + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== + async function * f16() { + yield * []; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== + async function * f17() { + await 1; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== + async function * f18() { + await; + ~ +!!! error TS1109: Expression expected. + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== + interface await {} + async function * f19() { + let x: await; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== + interface yield {} + async function * f20() { + let x: yield; + } +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== + async function * f21() { + const x = { [yield]: 1 }; + } \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt new file mode 100644 index 0000000000000..0eed47d203971 --- /dev/null +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt @@ -0,0 +1,171 @@ +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/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts (0 errors) ==== + const f1 = async function * f() { + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts (4 errors) ==== + const f2 = async function * await() { + ~~~~~ +!!! error TS1005: '(' expected. + ~~~~~ +!!! error TS2451: Cannot redeclare block-scoped variable 'await'. + ~ +!!! error TS1005: '=' expected. + ~ +!!! error TS1005: '=>' expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts (4 errors) ==== + const f3 = async function * yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~~~~~ +!!! error TS2451: Cannot redeclare block-scoped variable 'yield'. + ~ +!!! error TS1005: '=' expected. + ~ +!!! error TS1005: '=>' expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (3 errors) ==== + const f4 = async function * (await) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2451: Cannot redeclare block-scoped variable 'await'. + ~ +!!! error TS1005: ',' expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (3 errors) ==== + const f5 = async function * (yield) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2451: Cannot redeclare block-scoped variable 'yield'. + ~ +!!! error TS1005: ',' expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + 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) ==== + const f8 = async function * () { + async function * g() { + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== + const f9 = async function * () { + function yield() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '=>' expected. + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== + const f10 = async function * () { + const x = function yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=>' expected. + }; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== + const f11 = async function * () { + function await() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== + const f12 = async function * () { + const x = function await() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + }; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== + const f13 = async function * () { + yield; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== + const f14 = async function * () { + yield 1; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== + const f15 = async function * () { + yield *; + ~ +!!! error TS1109: Expression expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== + const f16 = async function * () { + yield * []; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== + const f17 = async function * () { + await 1; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== + const f18 = async function * () { + await; + ~ +!!! error TS1109: Expression expected. + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== + interface await {} + const f19 = async function * () { + let x: await; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== + interface yield {} + const f20 = async function * () { + let x: yield; + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== + const f21 = async function *() { + const x = { [yield]: 1 }; + }; + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt new file mode 100644 index 0000000000000..8215f418cdc54 --- /dev/null +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt @@ -0,0 +1,218 @@ +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,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,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/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== + const o1 = { + async * f() { + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== + const o2 = { + async * await() { + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== + const o3 = { + async * yield() { + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== + const o4 = { + async * f(await) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~ +!!! error TS1005: ':' expected. + ~ +!!! error TS1136: Property assignment expected. + } + }; + ~ +!!! error TS1128: Declaration or statement expected. +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== + const o5 = { + async * f(yield) { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~ +!!! error TS1005: ':' expected. + ~ +!!! error TS1136: Property assignment expected. + } + }; + ~ +!!! error TS1128: Declaration or statement expected. +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + 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) ==== + const o8 = { + async * f() { + async function * g() { + } + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== + const o9 = { + async * f() { + function yield() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '=>' expected. + } + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== + const o10 = { + async * f() { + const x = function yield() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=>' expected. + }; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== + const o11 = { + async * f() { + function await() { + ~~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + } + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== + const o12 = { + async * f() { + const x = function await() { + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1005: ';' expected. + }; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== + const o13 = { + async * f() { + yield; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== + const o14 = { + async * f() { + yield 1; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== + const o15 = { + async * f() { + yield *; + ~ +!!! error TS1109: Expression expected. + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== + const o16 = { + async * f() { + yield * []; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== + const o17 = { + async * f() { + await 1; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== + const o18 = { + async * f() { + await; + ~ +!!! error TS1109: Expression expected. + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== + interface await {} + const o19 = { + async * f() { + let x: await; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== + interface yield {} + const o20 = { + async * f() { + let x: yield; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== + const o21 = { + async * f() { + const x = { [yield]: 1 }; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== + const o22 = { + async * get x() { + ~ +!!! error TS1005: '(' expected. + return 1; + } + }; +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + const o24 = { + async * x: 1; + ~ +!!! error TS1005: '(' expected. + }; \ No newline at end of file diff --git a/tests/baselines/reference/parser.forAwait.esnext.errors.txt b/tests/baselines/reference/parser.forAwait.esnext.errors.txt new file mode 100644 index 0000000000000..44dfd947b56fb --- /dev/null +++ b/tests/baselines/reference/parser.forAwait.esnext.errors.txt @@ -0,0 +1,104 @@ +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/ecmascriptnext/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) ==== + for await (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 'x'. + ~ +!!! error TS2304: Cannot find name 'y'. + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + for await (x in y) { + ~ +!!! error TS2304: Cannot find name 'x'. + ~~ +!!! error TS1005: 'of' expected. + ~ +!!! error TS2304: Cannot find name 'y'. + } +==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts (1 errors) ==== + function f5() { + let y: any; + for await (const x of y) { + ~~~~~ +!!! 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) ==== + function f6() { + 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. + } + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + async function f8() { + let x: any, y: any; + for await (x of y) { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/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) ==== + async function* f10() { + let x: any, y: any; + for await (x of y) { + } + } +==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts (1 errors) ==== + function* f11() { + let y: any; + for await (const x of y) { + ~~~~~ +!!! 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) ==== + 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 diff --git a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt deleted file mode 100644 index 578c24e7ce90f..0000000000000 --- a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt +++ /dev/null @@ -1,11 +0,0 @@ -tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (1 errors) ==== - function* gen() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - // Once this is supported, the inner expression does not need to be parenthesized. - var x = yield `abc${ x }def`; - } - \ No newline at end of file diff --git a/tests/baselines/reference/templateStringInYieldKeyword.js b/tests/baselines/reference/templateStringInYieldKeyword.js index e23eaa17c9cc0..aaab38c194f40 100644 --- a/tests/baselines/reference/templateStringInYieldKeyword.js +++ b/tests/baselines/reference/templateStringInYieldKeyword.js @@ -8,5 +8,5 @@ function* gen() { //// [templateStringInYieldKeyword.js] function* gen() { // Once this is supported, the inner expression does not need to be parenthesized. - var x = yield "abc" + x + "def"; + var x = yield `abc${x}def`; } diff --git a/tests/baselines/reference/templateStringInYieldKeyword.symbols b/tests/baselines/reference/templateStringInYieldKeyword.symbols new file mode 100644 index 0000000000000..3e8e63d295459 --- /dev/null +++ b/tests/baselines/reference/templateStringInYieldKeyword.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts === +function* gen() { +>gen : Symbol(gen, Decl(templateStringInYieldKeyword.ts, 0, 0)) + + // Once this is supported, the inner expression does not need to be parenthesized. + var x = yield `abc${ x }def`; +>x : Symbol(x, Decl(templateStringInYieldKeyword.ts, 2, 7)) +>x : Symbol(x, Decl(templateStringInYieldKeyword.ts, 2, 7)) +} + diff --git a/tests/baselines/reference/templateStringInYieldKeyword.types b/tests/baselines/reference/templateStringInYieldKeyword.types new file mode 100644 index 0000000000000..3eff79cf79632 --- /dev/null +++ b/tests/baselines/reference/templateStringInYieldKeyword.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts === +function* gen() { +>gen : () => IterableIterator + + // Once this is supported, the inner expression does not need to be parenthesized. + var x = yield `abc${ x }def`; +>x : any +>yield `abc${ x }def` : any +>`abc${ x }def` : string +>x : any +} + diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt index 28f33943732e9..ce0d781d8246c 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt +++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt @@ -1,6 +1,8 @@ +error TS2318: Cannot find global type 'IterableIterator'. tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(1,15): error TS1005: '(' expected. +!!! error TS2318: Cannot find global type 'IterableIterator'. ==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts (1 errors) ==== function* gen { ~ diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js index 8230f0ec8f1e4..4192fc6fbe2c5 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js +++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js @@ -6,7 +6,43 @@ function* gen { //// [templateStringWithEmbeddedYieldKeyword.js] -function* gen() { - // Once this is supported, yield *must* be parenthesized. - var x = "abc" + (yield 10) + "def"; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function gen() { + var x, _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + _a = "abc"; + return [4 /*yield*/, 10]; + case 1: + x = _a + (_b.sent()) + "def"; + return [2 /*return*/]; + } + }); } diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.js b/tests/baselines/reference/transformNestedGeneratorsWithTry.js index 04bac08d307f5..28f405e47b9cd 100644 --- a/tests/baselines/reference/transformNestedGeneratorsWithTry.js +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.js @@ -33,8 +33,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; var __generator = (this && this.__generator) || function (thisArg, body) { - var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; - return { next: verb(0), "throw": verb(1), "return": verb(2) }; + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols b/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols new file mode 100644 index 0000000000000..0514b4e14243f --- /dev/null +++ b/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols @@ -0,0 +1,152 @@ +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +async function * inferReturnType1() { +>inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.esnext.1.ts, 0, 0)) +} +async function * inferReturnType2() { +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.1.ts, 1, 1)) + + yield; +} +async function * inferReturnType3() { +>inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 4, 1)) + + yield 1; +} +async function * inferReturnType4() { +>inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 7, 1)) + + yield* [1, 2]; +} +async function * inferReturnType5() { +>inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 10, 1)) + + yield* (async function * () { yield 1; })(); +} +const assignability1: () => AsyncIterableIterator = async function * () { +>assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.esnext.1.ts, 14, 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, 17, 5)) +>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +}; +const assignability3: () => AsyncIterableIterator = async function * () { +>assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.esnext.1.ts, 20, 5)) +>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* (async function * () { yield 1; })(); +}; +const assignability4: () => AsyncIterable = async function * () { +>assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.esnext.1.ts, 23, 5)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield 1; +}; +const assignability5: () => AsyncIterable = async function * () { +>assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.esnext.1.ts, 26, 5)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +}; +const assignability6: () => AsyncIterable = async function * () { +>assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.esnext.1.ts, 29, 5)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* (async function * () { yield 1; })(); +}; +const assignability7: () => AsyncIterator = async function * () { +>assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.esnext.1.ts, 32, 5)) +>AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield 1; +}; +const assignability8: () => AsyncIterator = async function * () { +>assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.esnext.1.ts, 35, 5)) +>AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +}; +const assignability9: () => AsyncIterator = async function * () { +>assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.esnext.1.ts, 38, 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, 40, 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, 43, 1)) +>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +} +async function * explicitReturnType3(): AsyncIterableIterator { +>explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 46, 1)) +>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* (async function * () { yield 1; })(); +} +async function * explicitReturnType4(): AsyncIterable { +>explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 49, 1)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield 1; +} +async function * explicitReturnType5(): AsyncIterable { +>explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 52, 1)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +} +async function * explicitReturnType6(): AsyncIterable { +>explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.esnext.1.ts, 55, 1)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* (async function * () { yield 1; })(); +} +async function * explicitReturnType7(): AsyncIterator { +>explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.esnext.1.ts, 58, 1)) +>AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield 1; +} +async function * explicitReturnType8(): AsyncIterator { +>explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.esnext.1.ts, 61, 1)) +>AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* [1, 2]; +} +async function * explicitReturnType9(): AsyncIterator { +>explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.esnext.1.ts, 64, 1)) +>AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) + + yield* (async function * () { yield 1; })(); +} +async function * explicitReturnType10(): {} { +>explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.esnext.1.ts, 67, 1)) + + yield 1; +} +async function * awaitedType1() { +>awaitedType1 : Symbol(awaitedType1, Decl(types.asyncGenerators.esnext.1.ts, 70, 1)) + + const x = await 1; +>x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 72, 9)) +} +async function * awaitedType2() { +>awaitedType2 : Symbol(awaitedType2, Decl(types.asyncGenerators.esnext.1.ts, 73, 1)) + + const x = await Promise.resolve(1); +>x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 75, 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.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.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.esnext.1.types new file mode 100644 index 0000000000000..a788f2d349fa5 --- /dev/null +++ b/tests/baselines/reference/types.asyncGenerators.esnext.1.types @@ -0,0 +1,262 @@ +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +async function * inferReturnType1() { +>inferReturnType1 : () => AsyncIterableIterator +} +async function * inferReturnType2() { +>inferReturnType2 : () => AsyncIterableIterator + + yield; +>yield : any +} +async function * inferReturnType3() { +>inferReturnType3 : () => AsyncIterableIterator<1> + + yield 1; +>yield 1 : any +>1 : 1 +} +async function * inferReturnType4() { +>inferReturnType4 : () => AsyncIterableIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 +} +async function * inferReturnType5() { +>inferReturnType5 : () => AsyncIterableIterator<1> + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +const assignability1: () => AsyncIterableIterator = async function * () { +>assignability1 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator +>async function * () { yield 1;} : () => AsyncIterableIterator<1> + + yield 1; +>yield 1 : any +>1 : 1 + +}; +const assignability2: () => AsyncIterableIterator = async function * () { +>assignability2 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator +>async function * () { yield* [1, 2];} : () => AsyncIterableIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +}; +const assignability3: () => AsyncIterableIterator = async function * () { +>assignability3 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<1> + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + +}; +const assignability4: () => AsyncIterable = async function * () { +>assignability4 : () => AsyncIterable +>AsyncIterable : AsyncIterable +>async function * () { yield 1;} : () => AsyncIterableIterator<1> + + yield 1; +>yield 1 : any +>1 : 1 + +}; +const assignability5: () => AsyncIterable = async function * () { +>assignability5 : () => AsyncIterable +>AsyncIterable : AsyncIterable +>async function * () { yield* [1, 2];} : () => AsyncIterableIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +}; +const assignability6: () => AsyncIterable = async function * () { +>assignability6 : () => AsyncIterable +>AsyncIterable : AsyncIterable +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<1> + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + +}; +const assignability7: () => AsyncIterator = async function * () { +>assignability7 : () => AsyncIterator +>AsyncIterator : AsyncIterator +>async function * () { yield 1;} : () => AsyncIterableIterator<1> + + yield 1; +>yield 1 : any +>1 : 1 + +}; +const assignability8: () => AsyncIterator = async function * () { +>assignability8 : () => AsyncIterator +>AsyncIterator : AsyncIterator +>async function * () { yield* [1, 2];} : () => AsyncIterableIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +}; +const assignability9: () => AsyncIterator = async function * () { +>assignability9 : () => AsyncIterator +>AsyncIterator : AsyncIterator +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<1> + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 + +}; +async function * explicitReturnType1(): AsyncIterableIterator { +>explicitReturnType1 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator + + yield 1; +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType2(): AsyncIterableIterator { +>explicitReturnType2 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 +} +async function * explicitReturnType3(): AsyncIterableIterator { +>explicitReturnType3 : () => AsyncIterableIterator +>AsyncIterableIterator : AsyncIterableIterator + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType4(): AsyncIterable { +>explicitReturnType4 : () => AsyncIterable +>AsyncIterable : AsyncIterable + + yield 1; +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType5(): AsyncIterable { +>explicitReturnType5 : () => AsyncIterable +>AsyncIterable : AsyncIterable + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 +} +async function * explicitReturnType6(): AsyncIterable { +>explicitReturnType6 : () => AsyncIterable +>AsyncIterable : AsyncIterable + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType7(): AsyncIterator { +>explicitReturnType7 : () => AsyncIterator +>AsyncIterator : AsyncIterator + + yield 1; +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType8(): AsyncIterator { +>explicitReturnType8 : () => AsyncIterator +>AsyncIterator : AsyncIterator + + yield* [1, 2]; +>yield* [1, 2] : any +>[1, 2] : number[] +>1 : 1 +>2 : 2 +} +async function * explicitReturnType9(): AsyncIterator { +>explicitReturnType9 : () => AsyncIterator +>AsyncIterator : AsyncIterator + + yield* (async function * () { yield 1; })(); +>yield* (async function * () { yield 1; })() : any +>(async function * () { yield 1; })() : AsyncIterableIterator<1> +>(async function * () { yield 1; }) : () => AsyncIterableIterator<1> +>async function * () { yield 1; } : () => AsyncIterableIterator<1> +>yield 1 : any +>1 : 1 +} +async function * explicitReturnType10(): {} { +>explicitReturnType10 : () => {} + + yield 1; +>yield 1 : any +>1 : 1 +} +async function * awaitedType1() { +>awaitedType1 : () => AsyncIterableIterator + + const x = await 1; +>x : 1 +>await 1 : 1 +>1 : 1 +} +async function * awaitedType2() { +>awaitedType2 : () => AsyncIterableIterator + + const x = await Promise.resolve(1); +>x : number +>await Promise.resolve(1) : number +>Promise.resolve(1) : Promise +>Promise.resolve : { (value: T | PromiseLike): Promise; (): Promise; } +>Promise : PromiseConstructor +>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.esnext.2.errors.txt new file mode 100644 index 0000000000000..c13620a7f9e41 --- /dev/null +++ b/tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt @@ -0,0 +1,212 @@ +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(7,7): error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterableIterator'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterableIterator'. + Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.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<"a">' is not assignable to type '() => AsyncIterableIterator'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterableIterator'. + Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterable'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterable'. + Types of property '[Symbol.asyncIterator]' are incompatible. + Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterator'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. + Types of property 'next' are incompatible. + Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => Promise>'. + Type 'Promise>' is not assignable to type 'Promise>'. + Type 'IteratorResult<"a">' is not assignable to type 'IteratorResult'. + Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.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'. + Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. + Types of property 'next' are incompatible. + Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => Promise>'. + 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<"a">' is not assignable to type '() => AsyncIterable'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterator'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.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<"a">' is not assignable to type '() => AsyncIterator'. + Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(35,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(38,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(41,12): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(44,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(47,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(50,12): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(53,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(56,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(59,12): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(61,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'IterableIterator'. + Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(64,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterable'. + Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(67,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 not assignable to type 'IteratorResult'. + Property 'done' is missing in type 'Promise>'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(71,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 (23 errors) ==== + async function * inferReturnType1() { + yield* {}; + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + async function * inferReturnType2() { + yield* inferReturnType2(); + } + const assignability1: () => AsyncIterableIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterableIterator'. +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + yield "a"; + }; + const assignability2: () => AsyncIterableIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. +!!! error TS2322: Type 'string' is not assignable to type 'number'. + yield* ["a", "b"]; + }; + const assignability3: () => AsyncIterableIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterableIterator'. +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + yield* (async function * () { yield "a"; })(); + }; + const assignability4: () => AsyncIterable = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterable'. +!!! error TS2322: Types of property '[Symbol.asyncIterator]' are incompatible. +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => Promise>'. +!!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. +!!! error TS2322: Type 'IteratorResult<"a">' is not assignable to type 'IteratorResult'. +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + yield "a"; + }; + const assignability5: () => AsyncIterable = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. +!!! error TS2322: Types of property '[Symbol.asyncIterator]' are incompatible. +!!! error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => Promise>'. +!!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. +!!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2322: Type 'string' is not assignable to type 'number'. + yield* ["a", "b"]; + }; + const assignability6: () => AsyncIterable = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterable'. + yield* (async function * () { yield "a"; })(); + }; + const assignability7: () => AsyncIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. + yield "a"; + }; + const assignability8: () => AsyncIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. + yield* ["a", "b"]; + }; + const assignability9: () => AsyncIterator = async function * () { + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '() => AsyncIterableIterator<"a">' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Type 'AsyncIterableIterator<"a">' is not assignable to type 'AsyncIterator'. + yield* (async function * () { yield "a"; })(); + }; + async function * explicitReturnType1(): AsyncIterableIterator { + yield "a"; + ~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType2(): AsyncIterableIterator { + yield* ["a", "b"]; + ~~~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + } + async function * explicitReturnType3(): AsyncIterableIterator { + yield* (async function * () { yield "a"; })(); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType4(): AsyncIterable { + yield "a"; + ~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType5(): AsyncIterable { + yield* ["a", "b"]; + ~~~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + } + async function * explicitReturnType6(): AsyncIterable { + yield* (async function * () { yield "a"; })(); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType7(): AsyncIterator { + yield "a"; + ~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType8(): AsyncIterator { + yield* ["a", "b"]; + ~~~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + } + async function * explicitReturnType9(): AsyncIterator { + yield* (async function * () { yield "a"; })(); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type '"a"' is not assignable to type 'number'. + } + async function * explicitReturnType10(): IterableIterator { + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'IterableIterator'. +!!! error TS2322: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator'. + yield 1; + } + async function * explicitReturnType11(): Iterable { + ~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterable'. +!!! error TS2322: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator'. + yield 1; + } + async function * explicitReturnType12(): Iterator { + ~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterator'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => IteratorResult'. +!!! error TS2322: Type 'Promise>' is not assignable to type 'IteratorResult'. +!!! error TS2322: Property 'done' is missing in type 'Promise>'. + yield 1; + } + async function * yieldStar() { + yield* {}; + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.esnext.1.symbols b/tests/baselines/reference/types.forAwait.esnext.1.symbols new file mode 100644 index 0000000000000..286f0a8555c54 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.esnext.1.symbols @@ -0,0 +1,55 @@ +=== 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, --, --)) + +async function f1() { +>f1 : Symbol(f1, Decl(types.forAwait.esnext.1.ts, 1, 41)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 3, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 4, 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, 6, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 3, 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, 3, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) + } +} +async function * f2() { +>f2 : Symbol(f2, Decl(types.forAwait.esnext.1.ts, 12, 1)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 14, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 15, 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, 17, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 14, 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, 14, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) + } +} diff --git a/tests/baselines/reference/types.forAwait.esnext.1.types b/tests/baselines/reference/types.forAwait.esnext.1.types new file mode 100644 index 0000000000000..6b20101ecbbc6 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.esnext.1.types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts === +declare const asyncIterable: AsyncIterable; +>asyncIterable : AsyncIterable +>AsyncIterable : AsyncIterable + +declare const iterable: Iterable; +>iterable : Iterable +>Iterable : Iterable + +async function f1() { +>f1 : () => Promise + + let y: number; +>y : number + + for await (const x of asyncIterable) { +>x : number +>asyncIterable : AsyncIterable + } + for await (const x of iterable) { +>x : number +>iterable : Iterable + } + for await (y of asyncIterable) { +>y : number +>asyncIterable : AsyncIterable + } + for await (y of iterable) { +>y : number +>iterable : Iterable + } +} +async function * f2() { +>f2 : () => AsyncIterableIterator + + let y: number; +>y : number + + for await (const x of asyncIterable) { +>x : number +>asyncIterable : AsyncIterable + } + for await (const x of iterable) { +>x : number +>iterable : Iterable + } + for await (y of asyncIterable) { +>y : number +>asyncIterable : AsyncIterable + } + for await (y of iterable) { +>y : number +>iterable : Iterable + } +} diff --git a/tests/baselines/reference/types.forAwait.esnext.2.errors.txt b/tests/baselines/reference/types.forAwait.esnext.2.errors.txt new file mode 100644 index 0000000000000..367dc5a282f50 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.esnext.2.errors.txt @@ -0,0 +1,39 @@ +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 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 must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts (6 errors) ==== + declare const asyncIterable: AsyncIterable; + declare const iterable: Iterable; + async function f() { + let y: number; + let z: string; + for await (const x of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + for await (y of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + for await (z of asyncIterable) { + ~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + for await (z of iterable) { + ~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + for (const x of asyncIterable) { + ~~~~~~~~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + } + for (y of asyncIterable) { + ~~~~~~~~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.esnext.3.errors.txt b/tests/baselines/reference/types.forAwait.esnext.3.errors.txt new file mode 100644 index 0000000000000..234e2eb0751b3 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.esnext.3.errors.txt @@ -0,0 +1,31 @@ +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. + + +!!! error TS2318: Cannot find global type 'AsyncIterableIterator'. +==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts (4 errors) ==== + async function f1() { + let y: number; + for await (const x of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + for await (y of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + } + async function* f2() { + let y: number; + for await (const x of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + for await (y of {}) { + ~~ +!!! error TS2504: Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/underscoreTest1.js b/tests/baselines/reference/underscoreTest1.js index 687a210e6707c..63e4c16ea1ea0 100644 --- a/tests/baselines/reference/underscoreTest1.js +++ b/tests/baselines/reference/underscoreTest1.js @@ -5,7 +5,7 @@ interface Dictionary { [x: string]: T; } -interface Iterator { +interface Iterator_ { (value: T, index: any, list: any): U; } @@ -81,10 +81,10 @@ module Underscore { } export interface WrappedArray extends WrappedObject> { - each(iterator: Iterator, context?: any): void; - forEach(iterator: Iterator, context?: any): void; - map(iterator: Iterator, context?: any): U[]; - collect(iterator: Iterator, context?: any): U[]; + each(iterator: Iterator_, context?: any): void; + forEach(iterator: Iterator_, context?: any): void; + map(iterator: Iterator_, context?: any): U[]; + collect(iterator: Iterator_, context?: any): U[]; reduce(iterator: Reducer, initialValue?: T, context?: any): T; reduce(iterator: Reducer, initialValue: U, context?: any): U; foldl(iterator: Reducer, initialValue?: T, context?: any): T; @@ -95,28 +95,28 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): U; foldr(iterator: Reducer, initialValue?: T, context?: any): T; foldr(iterator: Reducer, initialValue: U, context?: any): U; - find(iterator: Iterator, context?: any): T; - detect(iterator: Iterator, context?: any): T; - filter(iterator: Iterator, context?: any): T[]; - select(iterator: Iterator, context?: any): T[]; + find(iterator: Iterator_, context?: any): T; + detect(iterator: Iterator_, context?: any): T; + filter(iterator: Iterator_, context?: any): T[]; + select(iterator: Iterator_, context?: any): T[]; where(properties: Object): T[]; findWhere(properties: Object): T; - reject(iterator: Iterator, context?: any): T[]; - every(iterator?: Iterator, context?: any): boolean; - all(iterator?: Iterator, context?: any): boolean; - some(iterator?: Iterator, context?: any): boolean; - any(iterator?: Iterator, context?: any): boolean; + reject(iterator: Iterator_, context?: any): T[]; + every(iterator?: Iterator_, context?: any): boolean; + all(iterator?: Iterator_, context?: any): boolean; + some(iterator?: Iterator_, context?: any): boolean; + any(iterator?: Iterator_, context?: any): boolean; contains(value: T): boolean; include(value: T): boolean; invoke(methodName: string, ...args: any[]): any[]; pluck(propertyName: string): any[]; - max(iterator?: Iterator, context?: any): T; - min(iterator?: Iterator, context?: any): T; - sortBy(iterator: Iterator, context?: any): T[]; + max(iterator?: Iterator_, context?: any): T; + min(iterator?: Iterator_, context?: any): T; + sortBy(iterator: Iterator_, context?: any): T[]; sortBy(propertyName: string): T[]; - groupBy(iterator?: Iterator, context?: any): Dictionary; + groupBy(iterator?: Iterator_, context?: any): Dictionary; groupBy(propertyName: string): Dictionary; - countBy(iterator?: Iterator, context?: any): Dictionary; + countBy(iterator?: Iterator_, context?: any): Dictionary; countBy(propertyName: string): Dictionary; shuffle(): T[]; toArray(): T[]; @@ -139,16 +139,16 @@ module Underscore { intersection(...arrays: T[][]): T[]; difference(...others: T[][]): T[]; uniq(isSorted?: boolean): T[]; - uniq(isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): U[]; unique(isSorted?: boolean): T[]; - unique(isSorted: boolean, iterator: Iterator, context?: any): U[]; + unique(isSorted: boolean, iterator: Iterator_, context?: any): U[]; zip(...arrays: any[][]): any[][]; object(): any; object(values: any[]): any; indexOf(value: T, isSorted?: boolean): number; lastIndexOf(value: T, fromIndex?: number): number; sortedIndex(obj: T, propertyName: string): number; - sortedIndex(obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): number; // Methods from Array concat(...items: T[]): T[]; join(separator?: string): string; @@ -164,10 +164,10 @@ module Underscore { } export interface WrappedDictionary extends WrappedObject> { - each(iterator: Iterator, context?: any): void; - forEach(iterator: Iterator, context?: any): void; - map(iterator: Iterator, context?: any): U[]; - collect(iterator: Iterator, context?: any): U[]; + each(iterator: Iterator_, context?: any): void; + forEach(iterator: Iterator_, context?: any): void; + map(iterator: Iterator_, context?: any): U[]; + collect(iterator: Iterator_, context?: any): U[]; reduce(iterator: Reducer, initialValue?: T, context?: any): T; reduce(iterator: Reducer, initialValue: U, context?: any): U; foldl(iterator: Reducer, initialValue?: T, context?: any): T; @@ -178,28 +178,28 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): U; foldr(iterator: Reducer, initialValue?: T, context?: any): T; foldr(iterator: Reducer, initialValue: U, context?: any): U; - find(iterator: Iterator, context?: any): T; - detect(iterator: Iterator, context?: any): T; - filter(iterator: Iterator, context?: any): T[]; - select(iterator: Iterator, context?: any): T[]; + find(iterator: Iterator_, context?: any): T; + detect(iterator: Iterator_, context?: any): T; + filter(iterator: Iterator_, context?: any): T[]; + select(iterator: Iterator_, context?: any): T[]; where(properties: Object): T[]; findWhere(properties: Object): T; - reject(iterator: Iterator, context?: any): T[]; - every(iterator?: Iterator, context?: any): boolean; - all(iterator?: Iterator, context?: any): boolean; - some(iterator?: Iterator, context?: any): boolean; - any(iterator?: Iterator, context?: any): boolean; + reject(iterator: Iterator_, context?: any): T[]; + every(iterator?: Iterator_, context?: any): boolean; + all(iterator?: Iterator_, context?: any): boolean; + some(iterator?: Iterator_, context?: any): boolean; + any(iterator?: Iterator_, context?: any): boolean; contains(value: T): boolean; include(value: T): boolean; invoke(methodName: string, ...args: any[]): any[]; pluck(propertyName: string): any[]; - max(iterator?: Iterator, context?: any): T; - min(iterator?: Iterator, context?: any): T; - sortBy(iterator: Iterator, context?: any): T[]; + max(iterator?: Iterator_, context?: any): T; + min(iterator?: Iterator_, context?: any): T; + sortBy(iterator: Iterator_, context?: any): T[]; sortBy(propertyName: string): T[]; - groupBy(iterator?: Iterator, context?: any): Dictionary; + groupBy(iterator?: Iterator_, context?: any): Dictionary; groupBy(propertyName: string): Dictionary; - countBy(iterator?: Iterator, context?: any): Dictionary; + countBy(iterator?: Iterator_, context?: any): Dictionary; countBy(propertyName: string): Dictionary; shuffle(): T[]; toArray(): T[]; @@ -240,10 +240,10 @@ module Underscore { } export interface ChainedArray extends ChainedObject> { - each(iterator: Iterator, context?: any): ChainedObject; - forEach(iterator: Iterator, context?: any): ChainedObject; - map(iterator: Iterator, context?: any): ChainedArray; - collect(iterator: Iterator, context?: any): ChainedArray; + each(iterator: Iterator_, context?: any): ChainedObject; + forEach(iterator: Iterator_, context?: any): ChainedObject; + map(iterator: Iterator_, context?: any): ChainedArray; + collect(iterator: Iterator_, context?: any): ChainedArray; reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldl(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; @@ -254,29 +254,29 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue: U, context?: any): ChainedObject; - find(iterator: Iterator, context?: any): ChainedObject; - detect(iterator: Iterator, context?: any): ChainedObject; - filter(iterator: Iterator, context?: any): ChainedArray; - select(iterator: Iterator, context?: any): ChainedArray; + find(iterator: Iterator_, context?: any): ChainedObject; + detect(iterator: Iterator_, context?: any): ChainedObject; + filter(iterator: Iterator_, context?: any): ChainedArray; + select(iterator: Iterator_, context?: any): ChainedArray; where(properties: Object): ChainedArray; findWhere(properties: Object): ChainedObject; - reject(iterator: Iterator, context?: any): ChainedArray; - every(iterator?: Iterator, context?: any): ChainedObject; - all(iterator?: Iterator, context?: any): ChainedObject; - some(iterator?: Iterator, context?: any): ChainedObject; - any(iterator?: Iterator, context?: any): ChainedObject; + reject(iterator: Iterator_, context?: any): ChainedArray; + every(iterator?: Iterator_, context?: any): ChainedObject; + all(iterator?: Iterator_, context?: any): ChainedObject; + some(iterator?: Iterator_, context?: any): ChainedObject; + any(iterator?: Iterator_, context?: any): ChainedObject; contains(value: T): ChainedObject; include(value: T): ChainedObject; invoke(methodName: string, ...args: any[]): ChainedArray; pluck(propertyName: string): ChainedArray; - max(iterator?: Iterator, context?: any): ChainedObject; - min(iterator?: Iterator, context?: any): ChainedObject; - sortBy(iterator: Iterator, context?: any): ChainedArray; + max(iterator?: Iterator_, context?: any): ChainedObject; + min(iterator?: Iterator_, context?: any): ChainedObject; + sortBy(iterator: Iterator_, context?: any): ChainedArray; sortBy(propertyName: string): ChainedArray; // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; groupBy(propertyName: string): ChainedDictionary; - countBy(iterator?: Iterator, context?: any): ChainedDictionary; + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; countBy(propertyName: string): ChainedDictionary; shuffle(): ChainedArray; toArray(): ChainedArray; @@ -299,16 +299,16 @@ module Underscore { intersection(...arrays: T[][]): ChainedArray; difference(...others: T[][]): ChainedArray; uniq(isSorted?: boolean): ChainedArray; - uniq(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; unique(isSorted?: boolean): ChainedArray; - unique(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; + unique(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; zip(...arrays: any[][]): ChainedArray; object(): ChainedObject; object(values: any[]): ChainedObject; indexOf(value: T, isSorted?: boolean): ChainedObject; lastIndexOf(value: T, fromIndex?: number): ChainedObject; sortedIndex(obj: T, propertyName: string): ChainedObject; - sortedIndex(obj: T, iterator?: Iterator, context?: any): ChainedObject; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): ChainedObject; // Methods from Array concat(...items: T[]): ChainedArray; join(separator?: string): ChainedObject; @@ -331,10 +331,10 @@ module Underscore { } export interface ChainedDictionary extends ChainedObject> { - each(iterator: Iterator, context?: any): ChainedObject; - forEach(iterator: Iterator, context?: any): ChainedObject; - map(iterator: Iterator, context?: any): ChainedArray; - collect(iterator: Iterator, context?: any): ChainedArray; + each(iterator: Iterator_, context?: any): ChainedObject; + forEach(iterator: Iterator_, context?: any): ChainedObject; + map(iterator: Iterator_, context?: any): ChainedArray; + collect(iterator: Iterator_, context?: any): ChainedArray; reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldl(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; @@ -345,29 +345,29 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue: U, context?: any): ChainedObject; - find(iterator: Iterator, context?: any): ChainedObject; - detect(iterator: Iterator, context?: any): ChainedObject; - filter(iterator: Iterator, context?: any): ChainedArray; - select(iterator: Iterator, context?: any): ChainedArray; + find(iterator: Iterator_, context?: any): ChainedObject; + detect(iterator: Iterator_, context?: any): ChainedObject; + filter(iterator: Iterator_, context?: any): ChainedArray; + select(iterator: Iterator_, context?: any): ChainedArray; where(properties: Object): ChainedArray; findWhere(properties: Object): ChainedObject; - reject(iterator: Iterator, context?: any): ChainedArray; - every(iterator?: Iterator, context?: any): ChainedObject; - all(iterator?: Iterator, context?: any): ChainedObject; - some(iterator?: Iterator, context?: any): ChainedObject; - any(iterator?: Iterator, context?: any): ChainedObject; + reject(iterator: Iterator_, context?: any): ChainedArray; + every(iterator?: Iterator_, context?: any): ChainedObject; + all(iterator?: Iterator_, context?: any): ChainedObject; + some(iterator?: Iterator_, context?: any): ChainedObject; + any(iterator?: Iterator_, context?: any): ChainedObject; contains(value: T): ChainedObject; include(value: T): ChainedObject; invoke(methodName: string, ...args: any[]): ChainedArray; pluck(propertyName: string): ChainedArray; - max(iterator?: Iterator, context?: any): ChainedObject; - min(iterator?: Iterator, context?: any): ChainedObject; - sortBy(iterator: Iterator, context?: any): ChainedArray; + max(iterator?: Iterator_, context?: any): ChainedObject; + min(iterator?: Iterator_, context?: any): ChainedObject; + sortBy(iterator: Iterator_, context?: any): ChainedArray; sortBy(propertyName: string): ChainedArray; // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; groupBy(propertyName: string): ChainedDictionary; - countBy(iterator?: Iterator, context?: any): ChainedDictionary; + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; countBy(propertyName: string): ChainedDictionary; shuffle(): ChainedArray; toArray(): ChainedArray; @@ -398,15 +398,15 @@ module Underscore { chain(list: Dictionary): ChainedDictionary; chain(obj: T): ChainedObject; - each(list: T[], iterator: Iterator, context?: any): void; - each(list: Dictionary, iterator: Iterator, context?: any): void; - forEach(list: T[], iterator: Iterator, context?: any): void; - forEach(list: Dictionary, iterator: Iterator, context?: any): void; + each(list: T[], iterator: Iterator_, context?: any): void; + each(list: Dictionary, iterator: Iterator_, context?: any): void; + forEach(list: T[], iterator: Iterator_, context?: any): void; + forEach(list: Dictionary, iterator: Iterator_, context?: any): void; - map(list: T[], iterator: Iterator, context?: any): U[]; - map(list: Dictionary, iterator: Iterator, context?: any): U[]; - collect(list: T[], iterator: Iterator, context?: any): U[]; - collect(list: Dictionary, iterator: Iterator, context?: any): U[]; + map(list: T[], iterator: Iterator_, context?: any): U[]; + map(list: Dictionary, iterator: Iterator_, context?: any): U[]; + collect(list: T[], iterator: Iterator_, context?: any): U[]; + collect(list: Dictionary, iterator: Iterator_, context?: any): U[]; reduce(list: T[], iterator: Reducer, initialValue?: T, context?: any): T; reduce(list: T[], iterator: Reducer, initialValue: U, context?: any): U; @@ -430,15 +430,15 @@ module Underscore { foldr(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; foldr(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; - find(list: T[], iterator: Iterator, context?: any): T; - find(list: Dictionary, iterator: Iterator, context?: any): T; - detect(list: T[], iterator: Iterator, context?: any): T; - detect(list: Dictionary, iterator: Iterator, context?: any): T; + find(list: T[], iterator: Iterator_, context?: any): T; + find(list: Dictionary, iterator: Iterator_, context?: any): T; + detect(list: T[], iterator: Iterator_, context?: any): T; + detect(list: Dictionary, iterator: Iterator_, context?: any): T; - filter(list: T[], iterator: Iterator, context?: any): T[]; - filter(list: Dictionary, iterator: Iterator, context?: any): T[]; - select(list: T[], iterator: Iterator, context?: any): T[]; - select(list: Dictionary, iterator: Iterator, context?: any): T[]; + filter(list: T[], iterator: Iterator_, context?: any): T[]; + filter(list: Dictionary, iterator: Iterator_, context?: any): T[]; + select(list: T[], iterator: Iterator_, context?: any): T[]; + select(list: Dictionary, iterator: Iterator_, context?: any): T[]; where(list: T[], properties: Object): T[]; where(list: Dictionary, properties: Object): T[]; @@ -446,18 +446,18 @@ module Underscore { findWhere(list: T[], properties: Object): T; findWhere(list: Dictionary, properties: Object): T; - reject(list: T[], iterator: Iterator, context?: any): T[]; - reject(list: Dictionary, iterator: Iterator, context?: any): T[]; + reject(list: T[], iterator: Iterator_, context?: any): T[]; + reject(list: Dictionary, iterator: Iterator_, context?: any): T[]; - every(list: T[], iterator?: Iterator, context?: any): boolean; - every(list: Dictionary, iterator?: Iterator, context?: any): boolean; - all(list: T[], iterator?: Iterator, context?: any): boolean; - all(list: Dictionary, iterator?: Iterator, context?: any): boolean; + every(list: T[], iterator?: Iterator_, context?: any): boolean; + every(list: Dictionary, iterator?: Iterator_, context?: any): boolean; + all(list: T[], iterator?: Iterator_, context?: any): boolean; + all(list: Dictionary, iterator?: Iterator_, context?: any): boolean; - some(list: T[], iterator?: Iterator, context?: any): boolean; - some(list: Dictionary, iterator?: Iterator, context?: any): boolean; - any(list: T[], iterator?: Iterator, context?: any): boolean; - any(list: Dictionary, iterator?: Iterator, context?: any): boolean; + some(list: T[], iterator?: Iterator_, context?: any): boolean; + some(list: Dictionary, iterator?: Iterator_, context?: any): boolean; + any(list: T[], iterator?: Iterator_, context?: any): boolean; + any(list: Dictionary, iterator?: Iterator_, context?: any): boolean; contains(list: T[], value: T): boolean; contains(list: Dictionary, value: T): boolean; @@ -470,24 +470,24 @@ module Underscore { pluck(list: any[], propertyName: string): any[]; pluck(list: Dictionary, propertyName: string): any[]; - max(list: T[], iterator?: Iterator, context?: any): T; - max(list: Dictionary, iterator?: Iterator, context?: any): T; + max(list: T[], iterator?: Iterator_, context?: any): T; + max(list: Dictionary, iterator?: Iterator_, context?: any): T; - min(list: T[], iterator?: Iterator, context?: any): T; - min(list: Dictionary, iterator?: Iterator, context?: any): T; + min(list: T[], iterator?: Iterator_, context?: any): T; + min(list: Dictionary, iterator?: Iterator_, context?: any): T; - sortBy(list: T[], iterator: Iterator, context?: any): T[]; - sortBy(list: Dictionary, iterator: Iterator, context?: any): T[]; + sortBy(list: T[], iterator: Iterator_, context?: any): T[]; + sortBy(list: Dictionary, iterator: Iterator_, context?: any): T[]; sortBy(list: T[], propertyName: string): T[]; sortBy(list: Dictionary, propertyName: string): T[]; - groupBy(list: T[], iterator?: Iterator, context?: any): Dictionary; - groupBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; + groupBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; + groupBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; groupBy(list: T[], propertyName: string): Dictionary; groupBy(list: Dictionary, propertyName: string): Dictionary; - countBy(list: T[], iterator?: Iterator, context?: any): Dictionary; - countBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; + countBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; + countBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; countBy(list: T[], propertyName: string): Dictionary; countBy(list: Dictionary, propertyName: string): Dictionary; @@ -529,9 +529,9 @@ module Underscore { difference(list: T[], ...others: T[][]): T[]; uniq(list: T[], isSorted?: boolean): T[]; - uniq(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; unique(list: T[], isSorted?: boolean): T[]; - unique(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; + unique(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; zip(a0: T0[], a1: T1[]): Tuple2[]; zip(a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; @@ -546,7 +546,7 @@ module Underscore { lastIndexOf(list: T[], value: T, fromIndex?: number): number; sortedIndex(list: T[], obj: T, propertyName: string): number; - sortedIndex(list: T[], obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(list: T[], obj: T, iterator?: Iterator_, context?: any): number; range(stop: number): number[]; range(start: number, stop: number, step?: number): number[]; @@ -623,7 +623,7 @@ module Underscore { identity(value: T): T; - times(n: number, iterator: Iterator, context?: any): U[]; + times(n: number, iterator: Iterator_, context?: any): U[]; random(max: number): number; random(min: number, max: number): number; diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols index 89815bd2371a6..41b0c8110275a 100644 --- a/tests/baselines/reference/underscoreTest1.symbols +++ b/tests/baselines/reference/underscoreTest1.symbols @@ -9,9 +9,9 @@ declare function alert(x: string): void; >x : Symbol(x, Decl(underscoreTest1_underscoreTests.ts, 3, 23)) _.each([1, 2, 3], (num) => alert(num.toString())); ->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19)) >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14)) >num.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) @@ -19,9 +19,9 @@ _.each([1, 2, 3], (num) => alert(num.toString())); >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())); ->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 6, 8)) >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 6, 16)) >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24)) @@ -33,16 +33,16 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) _.map([1, 2, 3], (num) => num * 3); ->_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) +>_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) +>map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18)) _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3); ->_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) +>_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) +>map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 9, 7)) >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 9, 15)) >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 9, 23)) @@ -52,9 +52,9 @@ _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3); var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0); >sum : Symbol(sum, Decl(underscoreTest1_underscoreTests.ts, 11, 3)) ->_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36)) >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31)) @@ -78,17 +78,17 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []); var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >even : Symbol(even, Decl(underscoreTest1_underscoreTests.ts, 16, 3)) ->_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77)) +>_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 78)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77)) +>find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 78)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39)) var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >evens : Symbol(evens, Decl(underscoreTest1_underscoreTests.ts, 18, 3)) ->_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81)) +>_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 90), Decl(underscoreTest1_underscore.ts, 434, 82)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81)) +>filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 90), Decl(underscoreTest1_underscore.ts, 434, 82)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42)) @@ -105,38 +105,38 @@ var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 183)) _.where(listOfPlays, { author: "Shakespeare", year: 1611 }); ->_.where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53)) +>_.where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 92), Decl(underscoreTest1_underscore.ts, 439, 53)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53)) +>where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 92), Decl(underscoreTest1_underscore.ts, 439, 53)) >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3)) >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 21, 22)) >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 21, 45)) var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >odds : Symbol(odds, Decl(underscoreTest1_underscoreTests.ts, 23, 3)) ->_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81)) +>_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 82)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81)) +>reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 82)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41)) _.all([true, 1, null, 'yes'], _.identity); ->_.all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83)) +>_.all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 96), Decl(underscoreTest1_underscore.ts, 450, 84)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83)) +>all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 96), Decl(underscoreTest1_underscore.ts, 450, 84)) >_.identity : Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 618, 29)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >identity : Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 618, 29)) _.any([null, 0, 'yes', false]); ->_.any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83)) +>_.any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 95), Decl(underscoreTest1_underscore.ts, 455, 84)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83)) +>any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 95), Decl(underscoreTest1_underscore.ts, 455, 84)) _.contains([1, 2, 3], 3); ->_.contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50)) +>_.contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 94), Decl(underscoreTest1_underscore.ts, 458, 50)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50)) +>contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 94), Decl(underscoreTest1_underscore.ts, 458, 50)) _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); >_.invoke : Symbol(Underscore.Static.invoke, Decl(underscoreTest1_underscore.ts, 461, 59), Decl(underscoreTest1_underscore.ts, 463, 71)) @@ -159,9 +159,9 @@ _.pluck(stooges, 'name'); >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3)) _.max(stooges, (stooge) => stooge.age); ->_.max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73)) +>_.max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 74)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73)) +>max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 74)) >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3)) >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16)) >stooge.age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29)) @@ -172,15 +172,15 @@ var numbers = [10, 5, 100, 2, 1000]; >numbers : Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3)) _.min(numbers); ->_.min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73)) +>_.min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 84), Decl(underscoreTest1_underscore.ts, 472, 74)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73)) +>min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 84), Decl(underscoreTest1_underscore.ts, 472, 74)) >numbers : Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3)) _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); ->_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) +>_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) +>sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30)) >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) @@ -190,9 +190,9 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); // not sure how this is typechecking at all.. Math.floor(e) is number not string..? _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)); ->_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77)) +>_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 78)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77)) +>groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 78)) >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28)) >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38)) >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50)) @@ -202,9 +202,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28)) _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); ->_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28)) >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --)) >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) @@ -212,14 +212,14 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28)) _.groupBy(['one', 'two', 'three'], 'length'); ->_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd'); ->_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) +>_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) +>countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28)) @@ -312,9 +312,9 @@ _.uniq([1, 2, 1, 3, 1, 4]); >uniq : Symbol(Underscore.Static.uniq, Decl(underscoreTest1_underscore.ts, 525, 56), Decl(underscoreTest1_underscore.ts, 527, 52)) _.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); ->_.zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>_.zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) _.object(['moe', 'larry', 'curly'], [30, 40, 50]); >_.object : Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 535, 41), Decl(underscoreTest1_underscore.ts, 537, 35)) @@ -342,29 +342,29 @@ _.sortedIndex([10, 20, 30, 40, 50], 35); >sortedIndex : Symbol(Underscore.Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 542, 72), Decl(underscoreTest1_underscore.ts, 544, 72)) _.range(10); ->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) _.range(1, 11); ->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) _.range(0, 30, 5); ->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) _.range(0, 30, 5); ->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) _.range(0); ->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) /////////////////////////////////////////////////////////////////////////////////////// @@ -516,9 +516,9 @@ var renderNotes = _.after(notes.length, render); >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3)) _.each(notes, (note) => note.asyncSave({ success: renderNotes })); ->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) +>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3)) >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15)) >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15)) @@ -648,15 +648,15 @@ _.clone({ name: 'moe' }); _.chain([1, 2, 3, 200]) >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map(function (num) { return num * num }) .value : Symbol(Underscore.ChainedObject.value, Decl(underscoreTest1_underscore.ts, 234, 46)) ->_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81)) +>_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 82)) >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap : Symbol(Underscore.ChainedArray.tap, Decl(underscoreTest1_underscore.ts, 325, 33)) ->_.chain([1, 2, 3, 200]) .filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80)) +>_.chain([1, 2, 3, 200]) .filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 81)) >_.chain : Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 391, 38), Decl(underscoreTest1_underscore.ts, 393, 45), Decl(underscoreTest1_underscore.ts, 394, 60)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >chain : Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 391, 38), Decl(underscoreTest1_underscore.ts, 393, 45), Decl(underscoreTest1_underscore.ts, 394, 60)) .filter(function (num) { return num % 2 == 0; }) ->filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80)) +>filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 81)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22)) @@ -665,7 +665,7 @@ _.chain([1, 2, 3, 200]) >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14)) .map(function (num) { return num * num }) ->map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81)) +>map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 82)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19)) @@ -852,9 +852,9 @@ _.times(3, function (n) { genie.grantWishNumber(n); }); >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21)) _.random(0, 100); ->_.random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36)) +>_.random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 80), Decl(underscoreTest1_underscore.ts, 624, 36)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) ->random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36)) +>random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 80), Decl(underscoreTest1_underscore.ts, 624, 36)) _.mixin({ >_.mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 625, 49)) @@ -976,17 +976,17 @@ interface Dictionary { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 0, 21)) } -interface Iterator { ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) ->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19)) ->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21)) +interface Iterator_ { +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) +>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 20)) +>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 22)) (value: T, index: any, list: any): U; >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 5, 5)) ->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19)) +>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 20)) >index : Symbol(index, Decl(underscoreTest1_underscore.ts, 5, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 5, 26)) ->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21)) +>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 22)) } interface Reducer { @@ -1250,42 +1250,42 @@ module Underscore { >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - each(iterator: Iterator, context?: any): void; + each(iterator: Iterator_, context?: any): void; >each : Symbol(WrappedArray.each, Decl(underscoreTest1_underscore.ts, 79, 70)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 80, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 80, 41)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 80, 42)) - forEach(iterator: Iterator, context?: any): void; ->forEach : Symbol(WrappedArray.forEach, Decl(underscoreTest1_underscore.ts, 80, 63)) + forEach(iterator: Iterator_, context?: any): void; +>forEach : Symbol(WrappedArray.forEach, Decl(underscoreTest1_underscore.ts, 80, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 81, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 81, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 81, 45)) - map(iterator: Iterator, context?: any): U[]; ->map : Symbol(WrappedArray.map, Decl(underscoreTest1_underscore.ts, 81, 66)) + map(iterator: Iterator_, context?: any): U[]; +>map : Symbol(WrappedArray.map, Decl(underscoreTest1_underscore.ts, 81, 67)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 82, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 82, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 82, 41)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12)) - collect(iterator: Iterator, context?: any): U[]; ->collect : Symbol(WrappedArray.collect, Decl(underscoreTest1_underscore.ts, 82, 61)) + collect(iterator: Iterator_, context?: any): U[]; +>collect : Symbol(WrappedArray.collect, Decl(underscoreTest1_underscore.ts, 82, 62)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 83, 19)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 83, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 83, 45)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16)) reduce(iterator: Reducer, initialValue?: T, context?: any): T; ->reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76)) +>reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 66), Decl(underscoreTest1_underscore.ts, 84, 76)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 84, 15)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) @@ -1296,7 +1296,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) reduce(iterator: Reducer, initialValue: U, context?: any): U; ->reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76)) +>reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 66), Decl(underscoreTest1_underscore.ts, 84, 76)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 85, 18)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) @@ -1399,40 +1399,40 @@ module Underscore { >context : Symbol(context, Decl(underscoreTest1_underscore.ts, 93, 58)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14)) - find(iterator: Iterator, context?: any): T; + find(iterator: Iterator_, context?: any): T; >find : Symbol(WrappedArray.find, Decl(underscoreTest1_underscore.ts, 93, 77)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 94, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 94, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 94, 45)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - detect(iterator: Iterator, context?: any): T; ->detect : Symbol(WrappedArray.detect, Decl(underscoreTest1_underscore.ts, 94, 63)) + detect(iterator: Iterator_, context?: any): T; +>detect : Symbol(WrappedArray.detect, Decl(underscoreTest1_underscore.ts, 94, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 95, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 95, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 95, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - filter(iterator: Iterator, context?: any): T[]; ->filter : Symbol(WrappedArray.filter, Decl(underscoreTest1_underscore.ts, 95, 65)) + filter(iterator: Iterator_, context?: any): T[]; +>filter : Symbol(WrappedArray.filter, Decl(underscoreTest1_underscore.ts, 95, 66)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 96, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 96, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 96, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - select(iterator: Iterator, context?: any): T[]; ->select : Symbol(WrappedArray.select, Decl(underscoreTest1_underscore.ts, 96, 67)) + select(iterator: Iterator_, context?: any): T[]; +>select : Symbol(WrappedArray.select, Decl(underscoreTest1_underscore.ts, 96, 68)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 97, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 97, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 97, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) where(properties: Object): T[]; ->where : Symbol(WrappedArray.where, Decl(underscoreTest1_underscore.ts, 97, 67)) +>where : Symbol(WrappedArray.where, Decl(underscoreTest1_underscore.ts, 97, 68)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 98, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) @@ -1443,44 +1443,44 @@ module Underscore { >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - reject(iterator: Iterator, context?: any): T[]; + reject(iterator: Iterator_, context?: any): T[]; >reject : Symbol(WrappedArray.reject, Decl(underscoreTest1_underscore.ts, 99, 41)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 100, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 100, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 100, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - every(iterator?: Iterator, context?: any): boolean; ->every : Symbol(WrappedArray.every, Decl(underscoreTest1_underscore.ts, 100, 67)) + every(iterator?: Iterator_, context?: any): boolean; +>every : Symbol(WrappedArray.every, Decl(underscoreTest1_underscore.ts, 100, 68)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 101, 14)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 101, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 101, 47)) - all(iterator?: Iterator, context?: any): boolean; ->all : Symbol(WrappedArray.all, Decl(underscoreTest1_underscore.ts, 101, 71)) + all(iterator?: Iterator_, context?: any): boolean; +>all : Symbol(WrappedArray.all, Decl(underscoreTest1_underscore.ts, 101, 72)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 102, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 102, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 102, 45)) - some(iterator?: Iterator, context?: any): boolean; ->some : Symbol(WrappedArray.some, Decl(underscoreTest1_underscore.ts, 102, 69)) + some(iterator?: Iterator_, context?: any): boolean; +>some : Symbol(WrappedArray.some, Decl(underscoreTest1_underscore.ts, 102, 70)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 103, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 103, 45)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 103, 46)) - any(iterator?: Iterator, context?: any): boolean; ->any : Symbol(WrappedArray.any, Decl(underscoreTest1_underscore.ts, 103, 70)) + any(iterator?: Iterator_, context?: any): boolean; +>any : Symbol(WrappedArray.any, Decl(underscoreTest1_underscore.ts, 103, 71)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 104, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 104, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 104, 45)) contains(value: T): boolean; ->contains : Symbol(WrappedArray.contains, Decl(underscoreTest1_underscore.ts, 104, 69)) +>contains : Symbol(WrappedArray.contains, Decl(underscoreTest1_underscore.ts, 104, 70)) >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 105, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) @@ -1498,60 +1498,60 @@ module Underscore { >pluck : Symbol(WrappedArray.pluck, Decl(underscoreTest1_underscore.ts, 107, 58)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 108, 14)) - max(iterator?: Iterator, context?: any): T; + max(iterator?: Iterator_, context?: any): T; >max : Symbol(WrappedArray.max, Decl(underscoreTest1_underscore.ts, 108, 43)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 109, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 109, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 109, 41)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - min(iterator?: Iterator, context?: any): T; ->min : Symbol(WrappedArray.min, Decl(underscoreTest1_underscore.ts, 109, 59)) + min(iterator?: Iterator_, context?: any): T; +>min : Symbol(WrappedArray.min, Decl(underscoreTest1_underscore.ts, 109, 60)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 110, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 110, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 110, 41)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - sortBy(iterator: Iterator, context?: any): T[]; ->sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63)) + sortBy(iterator: Iterator_, context?: any): T[]; +>sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 60), Decl(underscoreTest1_underscore.ts, 111, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 111, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 111, 42)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 111, 43)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) sortBy(propertyName: string): T[]; ->sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63)) +>sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 60), Decl(underscoreTest1_underscore.ts, 111, 64)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 112, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - groupBy(iterator?: Iterator, context?: any): Dictionary; ->groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77)) + groupBy(iterator?: Iterator_, context?: any): Dictionary; +>groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 78)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 113, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 113, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 113, 45)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) groupBy(propertyName: string): Dictionary; ->groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77)) +>groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 78)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 114, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - countBy(iterator?: Iterator, context?: any): Dictionary; ->countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80)) + countBy(iterator?: Iterator_, context?: any): Dictionary; +>countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 81)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 115, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 115, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 115, 45)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) countBy(propertyName: string): Dictionary; ->countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80)) +>countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 81)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 116, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -1655,35 +1655,35 @@ module Underscore { >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 137, 13)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - uniq(isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): U[]; >uniq : Symbol(WrappedArray.uniq, Decl(underscoreTest1_underscore.ts, 136, 42), Decl(underscoreTest1_underscore.ts, 137, 38)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 138, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 138, 34)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 138, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 138, 61)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13)) unique(isSorted?: boolean): T[]; ->unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40)) +>unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 82), Decl(underscoreTest1_underscore.ts, 139, 40)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 139, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) - unique(isSorted: boolean, iterator: Iterator, context?: any): U[]; ->unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40)) + unique(isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 82), Decl(underscoreTest1_underscore.ts, 139, 40)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 140, 18)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 140, 36)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 140, 62)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 140, 63)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15)) zip(...arrays: any[][]): any[][]; ->zip : Symbol(WrappedArray.zip, Decl(underscoreTest1_underscore.ts, 140, 83)) +>zip : Symbol(WrappedArray.zip, Decl(underscoreTest1_underscore.ts, 140, 84)) >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 141, 12)) object(): any; @@ -1711,18 +1711,18 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 146, 27)) - sortedIndex(obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): number; >sortedIndex : Symbol(WrappedArray.sortedIndex, Decl(underscoreTest1_underscore.ts, 145, 58), Decl(underscoreTest1_underscore.ts, 146, 58)) >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 147, 20)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 147, 27)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 147, 56)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 147, 57)) // Methods from Array concat(...items: T[]): T[]; ->concat : Symbol(WrappedArray.concat, Decl(underscoreTest1_underscore.ts, 147, 80)) +>concat : Symbol(WrappedArray.concat, Decl(underscoreTest1_underscore.ts, 147, 81)) >items : Symbol(items, Decl(underscoreTest1_underscore.ts, 149, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) @@ -1789,42 +1789,42 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - each(iterator: Iterator, context?: any): void; + each(iterator: Iterator_, context?: any): void; >each : Symbol(WrappedDictionary.each, Decl(underscoreTest1_underscore.ts, 162, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 163, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 163, 41)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 163, 42)) - forEach(iterator: Iterator, context?: any): void; ->forEach : Symbol(WrappedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 163, 63)) + forEach(iterator: Iterator_, context?: any): void; +>forEach : Symbol(WrappedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 163, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 164, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 164, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 164, 45)) - map(iterator: Iterator, context?: any): U[]; ->map : Symbol(WrappedDictionary.map, Decl(underscoreTest1_underscore.ts, 164, 66)) + map(iterator: Iterator_, context?: any): U[]; +>map : Symbol(WrappedDictionary.map, Decl(underscoreTest1_underscore.ts, 164, 67)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 165, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 165, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 165, 41)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12)) - collect(iterator: Iterator, context?: any): U[]; ->collect : Symbol(WrappedDictionary.collect, Decl(underscoreTest1_underscore.ts, 165, 61)) + collect(iterator: Iterator_, context?: any): U[]; +>collect : Symbol(WrappedDictionary.collect, Decl(underscoreTest1_underscore.ts, 165, 62)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 166, 19)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 166, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 166, 45)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16)) reduce(iterator: Reducer, initialValue?: T, context?: any): T; ->reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76)) +>reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 66), Decl(underscoreTest1_underscore.ts, 167, 76)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 167, 15)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) @@ -1835,7 +1835,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) reduce(iterator: Reducer, initialValue: U, context?: any): U; ->reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76)) +>reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 66), Decl(underscoreTest1_underscore.ts, 167, 76)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 168, 18)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) @@ -1938,40 +1938,40 @@ module Underscore { >context : Symbol(context, Decl(underscoreTest1_underscore.ts, 176, 58)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14)) - find(iterator: Iterator, context?: any): T; + find(iterator: Iterator_, context?: any): T; >find : Symbol(WrappedDictionary.find, Decl(underscoreTest1_underscore.ts, 176, 77)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 177, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 177, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 177, 45)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - detect(iterator: Iterator, context?: any): T; ->detect : Symbol(WrappedDictionary.detect, Decl(underscoreTest1_underscore.ts, 177, 63)) + detect(iterator: Iterator_, context?: any): T; +>detect : Symbol(WrappedDictionary.detect, Decl(underscoreTest1_underscore.ts, 177, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 178, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 178, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 178, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - filter(iterator: Iterator, context?: any): T[]; ->filter : Symbol(WrappedDictionary.filter, Decl(underscoreTest1_underscore.ts, 178, 65)) + filter(iterator: Iterator_, context?: any): T[]; +>filter : Symbol(WrappedDictionary.filter, Decl(underscoreTest1_underscore.ts, 178, 66)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 179, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 179, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 179, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - select(iterator: Iterator, context?: any): T[]; ->select : Symbol(WrappedDictionary.select, Decl(underscoreTest1_underscore.ts, 179, 67)) + select(iterator: Iterator_, context?: any): T[]; +>select : Symbol(WrappedDictionary.select, Decl(underscoreTest1_underscore.ts, 179, 68)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 180, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 180, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 180, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) where(properties: Object): T[]; ->where : Symbol(WrappedDictionary.where, Decl(underscoreTest1_underscore.ts, 180, 67)) +>where : Symbol(WrappedDictionary.where, Decl(underscoreTest1_underscore.ts, 180, 68)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 181, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) @@ -1982,44 +1982,44 @@ module Underscore { >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - reject(iterator: Iterator, context?: any): T[]; + reject(iterator: Iterator_, context?: any): T[]; >reject : Symbol(WrappedDictionary.reject, Decl(underscoreTest1_underscore.ts, 182, 41)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 183, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 183, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 183, 47)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - every(iterator?: Iterator, context?: any): boolean; ->every : Symbol(WrappedDictionary.every, Decl(underscoreTest1_underscore.ts, 183, 67)) + every(iterator?: Iterator_, context?: any): boolean; +>every : Symbol(WrappedDictionary.every, Decl(underscoreTest1_underscore.ts, 183, 68)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 184, 14)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 184, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 184, 47)) - all(iterator?: Iterator, context?: any): boolean; ->all : Symbol(WrappedDictionary.all, Decl(underscoreTest1_underscore.ts, 184, 71)) + all(iterator?: Iterator_, context?: any): boolean; +>all : Symbol(WrappedDictionary.all, Decl(underscoreTest1_underscore.ts, 184, 72)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 185, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 185, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 185, 45)) - some(iterator?: Iterator, context?: any): boolean; ->some : Symbol(WrappedDictionary.some, Decl(underscoreTest1_underscore.ts, 185, 69)) + some(iterator?: Iterator_, context?: any): boolean; +>some : Symbol(WrappedDictionary.some, Decl(underscoreTest1_underscore.ts, 185, 70)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 186, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 186, 45)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 186, 46)) - any(iterator?: Iterator, context?: any): boolean; ->any : Symbol(WrappedDictionary.any, Decl(underscoreTest1_underscore.ts, 186, 70)) + any(iterator?: Iterator_, context?: any): boolean; +>any : Symbol(WrappedDictionary.any, Decl(underscoreTest1_underscore.ts, 186, 71)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 187, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 187, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 187, 45)) contains(value: T): boolean; ->contains : Symbol(WrappedDictionary.contains, Decl(underscoreTest1_underscore.ts, 187, 69)) +>contains : Symbol(WrappedDictionary.contains, Decl(underscoreTest1_underscore.ts, 187, 70)) >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 188, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) @@ -2037,60 +2037,60 @@ module Underscore { >pluck : Symbol(WrappedDictionary.pluck, Decl(underscoreTest1_underscore.ts, 190, 58)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 191, 14)) - max(iterator?: Iterator, context?: any): T; + max(iterator?: Iterator_, context?: any): T; >max : Symbol(WrappedDictionary.max, Decl(underscoreTest1_underscore.ts, 191, 43)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 192, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 192, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 192, 41)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - min(iterator?: Iterator, context?: any): T; ->min : Symbol(WrappedDictionary.min, Decl(underscoreTest1_underscore.ts, 192, 59)) + min(iterator?: Iterator_, context?: any): T; +>min : Symbol(WrappedDictionary.min, Decl(underscoreTest1_underscore.ts, 192, 60)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 193, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 193, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 193, 41)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - sortBy(iterator: Iterator, context?: any): T[]; ->sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63)) + sortBy(iterator: Iterator_, context?: any): T[]; +>sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 60), Decl(underscoreTest1_underscore.ts, 194, 64)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 194, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 194, 42)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 194, 43)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) sortBy(propertyName: string): T[]; ->sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63)) +>sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 60), Decl(underscoreTest1_underscore.ts, 194, 64)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 195, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - groupBy(iterator?: Iterator, context?: any): Dictionary; ->groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77)) + groupBy(iterator?: Iterator_, context?: any): Dictionary; +>groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 78)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 196, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 196, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 196, 45)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) groupBy(propertyName: string): Dictionary; ->groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77)) +>groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 78)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 197, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) - countBy(iterator?: Iterator, context?: any): Dictionary; ->countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80)) + countBy(iterator?: Iterator_, context?: any): Dictionary; +>countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 81)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 198, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 198, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 198, 45)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) countBy(propertyName: string): Dictionary; ->countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80)) +>countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 81)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 199, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -2254,46 +2254,46 @@ module Underscore { >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - each(iterator: Iterator, context?: any): ChainedObject; + each(iterator: Iterator_, context?: any): ChainedObject; >each : Symbol(ChainedArray.each, Decl(underscoreTest1_underscore.ts, 238, 70)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 239, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 239, 41)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 239, 42)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - forEach(iterator: Iterator, context?: any): ChainedObject; ->forEach : Symbol(ChainedArray.forEach, Decl(underscoreTest1_underscore.ts, 239, 78)) + forEach(iterator: Iterator_, context?: any): ChainedObject; +>forEach : Symbol(ChainedArray.forEach, Decl(underscoreTest1_underscore.ts, 239, 79)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 240, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 240, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 240, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - map(iterator: Iterator, context?: any): ChainedArray; ->map : Symbol(ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81)) + map(iterator: Iterator_, context?: any): ChainedArray; +>map : Symbol(ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 82)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 241, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 241, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 241, 41)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12)) - collect(iterator: Iterator, context?: any): ChainedArray; ->collect : Symbol(ChainedArray.collect, Decl(underscoreTest1_underscore.ts, 241, 73)) + collect(iterator: Iterator_, context?: any): ChainedArray; +>collect : Symbol(ChainedArray.collect, Decl(underscoreTest1_underscore.ts, 241, 74)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 242, 19)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 242, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 242, 45)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16)) reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; ->reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91)) +>reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 78), Decl(underscoreTest1_underscore.ts, 243, 91)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 243, 15)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) @@ -2305,7 +2305,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; ->reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91)) +>reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 78), Decl(underscoreTest1_underscore.ts, 243, 91)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 244, 18)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) @@ -2417,44 +2417,44 @@ module Underscore { >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14)) - find(iterator: Iterator, context?: any): ChainedObject; + find(iterator: Iterator_, context?: any): ChainedObject; >find : Symbol(ChainedArray.find, Decl(underscoreTest1_underscore.ts, 252, 92)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 253, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 253, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 253, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - detect(iterator: Iterator, context?: any): ChainedObject; ->detect : Symbol(ChainedArray.detect, Decl(underscoreTest1_underscore.ts, 253, 78)) + detect(iterator: Iterator_, context?: any): ChainedObject; +>detect : Symbol(ChainedArray.detect, Decl(underscoreTest1_underscore.ts, 253, 79)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 254, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 254, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 254, 47)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - filter(iterator: Iterator, context?: any): ChainedArray; ->filter : Symbol(ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80)) + filter(iterator: Iterator_, context?: any): ChainedArray; +>filter : Symbol(ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 81)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 255, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 255, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 255, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - select(iterator: Iterator, context?: any): ChainedArray; ->select : Symbol(ChainedArray.select, Decl(underscoreTest1_underscore.ts, 255, 79)) + select(iterator: Iterator_, context?: any): ChainedArray; +>select : Symbol(ChainedArray.select, Decl(underscoreTest1_underscore.ts, 255, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 256, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 256, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 256, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) where(properties: Object): ChainedArray; ->where : Symbol(ChainedArray.where, Decl(underscoreTest1_underscore.ts, 256, 79)) +>where : Symbol(ChainedArray.where, Decl(underscoreTest1_underscore.ts, 256, 80)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 257, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) @@ -2467,49 +2467,49 @@ module Underscore { >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - reject(iterator: Iterator, context?: any): ChainedArray; + reject(iterator: Iterator_, context?: any): ChainedArray; >reject : Symbol(ChainedArray.reject, Decl(underscoreTest1_underscore.ts, 258, 56)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 259, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 259, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 259, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - every(iterator?: Iterator, context?: any): ChainedObject; ->every : Symbol(ChainedArray.every, Decl(underscoreTest1_underscore.ts, 259, 79)) + every(iterator?: Iterator_, context?: any): ChainedObject; +>every : Symbol(ChainedArray.every, Decl(underscoreTest1_underscore.ts, 259, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 260, 14)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 260, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 260, 47)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - all(iterator?: Iterator, context?: any): ChainedObject; ->all : Symbol(ChainedArray.all, Decl(underscoreTest1_underscore.ts, 260, 86)) + all(iterator?: Iterator_, context?: any): ChainedObject; +>all : Symbol(ChainedArray.all, Decl(underscoreTest1_underscore.ts, 260, 87)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 261, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 261, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 261, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - some(iterator?: Iterator, context?: any): ChainedObject; ->some : Symbol(ChainedArray.some, Decl(underscoreTest1_underscore.ts, 261, 84)) + some(iterator?: Iterator_, context?: any): ChainedObject; +>some : Symbol(ChainedArray.some, Decl(underscoreTest1_underscore.ts, 261, 85)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 262, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 262, 45)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 262, 46)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - any(iterator?: Iterator, context?: any): ChainedObject; ->any : Symbol(ChainedArray.any, Decl(underscoreTest1_underscore.ts, 262, 85)) + any(iterator?: Iterator_, context?: any): ChainedObject; +>any : Symbol(ChainedArray.any, Decl(underscoreTest1_underscore.ts, 262, 86)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 263, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 263, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 263, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) contains(value: T): ChainedObject; ->contains : Symbol(ChainedArray.contains, Decl(underscoreTest1_underscore.ts, 263, 84)) +>contains : Symbol(ChainedArray.contains, Decl(underscoreTest1_underscore.ts, 263, 85)) >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 264, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) @@ -2531,63 +2531,63 @@ module Underscore { >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 267, 14)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) - max(iterator?: Iterator, context?: any): ChainedObject; + max(iterator?: Iterator_, context?: any): ChainedObject; >max : Symbol(ChainedArray.max, Decl(underscoreTest1_underscore.ts, 267, 55)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 268, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 268, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 268, 41)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - min(iterator?: Iterator, context?: any): ChainedObject; ->min : Symbol(ChainedArray.min, Decl(underscoreTest1_underscore.ts, 268, 74)) + min(iterator?: Iterator_, context?: any): ChainedObject; +>min : Symbol(ChainedArray.min, Decl(underscoreTest1_underscore.ts, 268, 75)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 269, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 269, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 269, 41)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - sortBy(iterator: Iterator, context?: any): ChainedArray; ->sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75)) + sortBy(iterator: Iterator_, context?: any): ChainedArray; +>sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 75), Decl(underscoreTest1_underscore.ts, 270, 76)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 270, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 270, 42)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 270, 43)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) sortBy(propertyName: string): ChainedArray; ->sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75)) +>sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 75), Decl(underscoreTest1_underscore.ts, 270, 76)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 271, 15)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; ->groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86)) + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 87)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 273, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 273, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 273, 45)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) groupBy(propertyName: string): ChainedDictionary; ->groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86)) +>groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 87)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 274, 16)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) - countBy(iterator?: Iterator, context?: any): ChainedDictionary; ->countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87)) + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 88)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 275, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 275, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 275, 45)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) countBy(propertyName: string): ChainedDictionary; ->countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87)) +>countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 88)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 276, 16)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) @@ -2712,38 +2712,38 @@ module Underscore { >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - uniq(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; >uniq : Symbol(ChainedArray.uniq, Decl(underscoreTest1_underscore.ts, 296, 54), Decl(underscoreTest1_underscore.ts, 297, 50)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 298, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 298, 34)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 298, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 298, 61)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13)) unique(isSorted?: boolean): ChainedArray; ->unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52)) +>unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 94), Decl(underscoreTest1_underscore.ts, 299, 52)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 299, 15)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) - unique(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; ->unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52)) + unique(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; +>unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 94), Decl(underscoreTest1_underscore.ts, 299, 52)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 300, 18)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 300, 36)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 300, 62)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 300, 63)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15)) zip(...arrays: any[][]): ChainedArray; ->zip : Symbol(ChainedArray.zip, Decl(underscoreTest1_underscore.ts, 300, 95)) +>zip : Symbol(ChainedArray.zip, Decl(underscoreTest1_underscore.ts, 300, 96)) >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 301, 12)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) @@ -2777,19 +2777,19 @@ module Underscore { >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 306, 27)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - sortedIndex(obj: T, iterator?: Iterator, context?: any): ChainedObject; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): ChainedObject; >sortedIndex : Symbol(ChainedArray.sortedIndex, Decl(underscoreTest1_underscore.ts, 305, 73), Decl(underscoreTest1_underscore.ts, 306, 73)) >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 307, 20)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 307, 27)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 307, 56)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 307, 57)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) // Methods from Array concat(...items: T[]): ChainedArray; ->concat : Symbol(ChainedArray.concat, Decl(underscoreTest1_underscore.ts, 307, 95)) +>concat : Symbol(ChainedArray.concat, Decl(underscoreTest1_underscore.ts, 307, 96)) >items : Symbol(items, Decl(underscoreTest1_underscore.ts, 309, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) @@ -2905,46 +2905,46 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - each(iterator: Iterator, context?: any): ChainedObject; + each(iterator: Iterator_, context?: any): ChainedObject; >each : Symbol(ChainedDictionary.each, Decl(underscoreTest1_underscore.ts, 329, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 330, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 330, 41)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 330, 42)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - forEach(iterator: Iterator, context?: any): ChainedObject; ->forEach : Symbol(ChainedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 330, 78)) + forEach(iterator: Iterator_, context?: any): ChainedObject; +>forEach : Symbol(ChainedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 330, 79)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 331, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 331, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 331, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - map(iterator: Iterator, context?: any): ChainedArray; ->map : Symbol(ChainedDictionary.map, Decl(underscoreTest1_underscore.ts, 331, 81)) + map(iterator: Iterator_, context?: any): ChainedArray; +>map : Symbol(ChainedDictionary.map, Decl(underscoreTest1_underscore.ts, 331, 82)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 332, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 332, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 332, 41)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12)) - collect(iterator: Iterator, context?: any): ChainedArray; ->collect : Symbol(ChainedDictionary.collect, Decl(underscoreTest1_underscore.ts, 332, 73)) + collect(iterator: Iterator_, context?: any): ChainedArray; +>collect : Symbol(ChainedDictionary.collect, Decl(underscoreTest1_underscore.ts, 332, 74)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 333, 19)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 333, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 333, 45)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16)) reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; ->reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91)) +>reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 78), Decl(underscoreTest1_underscore.ts, 334, 91)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 334, 15)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) @@ -2956,7 +2956,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; ->reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91)) +>reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 78), Decl(underscoreTest1_underscore.ts, 334, 91)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 335, 18)) >Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1)) @@ -3068,44 +3068,44 @@ module Underscore { >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14)) - find(iterator: Iterator, context?: any): ChainedObject; + find(iterator: Iterator_, context?: any): ChainedObject; >find : Symbol(ChainedDictionary.find, Decl(underscoreTest1_underscore.ts, 343, 92)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 344, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 344, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 344, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - detect(iterator: Iterator, context?: any): ChainedObject; ->detect : Symbol(ChainedDictionary.detect, Decl(underscoreTest1_underscore.ts, 344, 78)) + detect(iterator: Iterator_, context?: any): ChainedObject; +>detect : Symbol(ChainedDictionary.detect, Decl(underscoreTest1_underscore.ts, 344, 79)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 345, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 345, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 345, 47)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - filter(iterator: Iterator, context?: any): ChainedArray; ->filter : Symbol(ChainedDictionary.filter, Decl(underscoreTest1_underscore.ts, 345, 80)) + filter(iterator: Iterator_, context?: any): ChainedArray; +>filter : Symbol(ChainedDictionary.filter, Decl(underscoreTest1_underscore.ts, 345, 81)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 346, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 346, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 346, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - select(iterator: Iterator, context?: any): ChainedArray; ->select : Symbol(ChainedDictionary.select, Decl(underscoreTest1_underscore.ts, 346, 79)) + select(iterator: Iterator_, context?: any): ChainedArray; +>select : Symbol(ChainedDictionary.select, Decl(underscoreTest1_underscore.ts, 346, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 347, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 347, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 347, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) where(properties: Object): ChainedArray; ->where : Symbol(ChainedDictionary.where, Decl(underscoreTest1_underscore.ts, 347, 79)) +>where : Symbol(ChainedDictionary.where, Decl(underscoreTest1_underscore.ts, 347, 80)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 348, 14)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) @@ -3118,49 +3118,49 @@ module Underscore { >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - reject(iterator: Iterator, context?: any): ChainedArray; + reject(iterator: Iterator_, context?: any): ChainedArray; >reject : Symbol(ChainedDictionary.reject, Decl(underscoreTest1_underscore.ts, 349, 56)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 350, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 350, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 350, 47)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - every(iterator?: Iterator, context?: any): ChainedObject; ->every : Symbol(ChainedDictionary.every, Decl(underscoreTest1_underscore.ts, 350, 79)) + every(iterator?: Iterator_, context?: any): ChainedObject; +>every : Symbol(ChainedDictionary.every, Decl(underscoreTest1_underscore.ts, 350, 80)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 351, 14)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 351, 46)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 351, 47)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - all(iterator?: Iterator, context?: any): ChainedObject; ->all : Symbol(ChainedDictionary.all, Decl(underscoreTest1_underscore.ts, 351, 86)) + all(iterator?: Iterator_, context?: any): ChainedObject; +>all : Symbol(ChainedDictionary.all, Decl(underscoreTest1_underscore.ts, 351, 87)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 352, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 352, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 352, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - some(iterator?: Iterator, context?: any): ChainedObject; ->some : Symbol(ChainedDictionary.some, Decl(underscoreTest1_underscore.ts, 352, 84)) + some(iterator?: Iterator_, context?: any): ChainedObject; +>some : Symbol(ChainedDictionary.some, Decl(underscoreTest1_underscore.ts, 352, 85)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 353, 13)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 353, 45)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 353, 46)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) - any(iterator?: Iterator, context?: any): ChainedObject; ->any : Symbol(ChainedDictionary.any, Decl(underscoreTest1_underscore.ts, 353, 85)) + any(iterator?: Iterator_, context?: any): ChainedObject; +>any : Symbol(ChainedDictionary.any, Decl(underscoreTest1_underscore.ts, 353, 86)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 354, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 354, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 354, 45)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) contains(value: T): ChainedObject; ->contains : Symbol(ChainedDictionary.contains, Decl(underscoreTest1_underscore.ts, 354, 84)) +>contains : Symbol(ChainedDictionary.contains, Decl(underscoreTest1_underscore.ts, 354, 85)) >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 355, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) @@ -3182,63 +3182,63 @@ module Underscore { >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 358, 14)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) - max(iterator?: Iterator, context?: any): ChainedObject; + max(iterator?: Iterator_, context?: any): ChainedObject; >max : Symbol(ChainedDictionary.max, Decl(underscoreTest1_underscore.ts, 358, 55)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 359, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 359, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 359, 41)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - min(iterator?: Iterator, context?: any): ChainedObject; ->min : Symbol(ChainedDictionary.min, Decl(underscoreTest1_underscore.ts, 359, 74)) + min(iterator?: Iterator_, context?: any): ChainedObject; +>min : Symbol(ChainedDictionary.min, Decl(underscoreTest1_underscore.ts, 359, 75)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 360, 12)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 360, 40)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 360, 41)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) - sortBy(iterator: Iterator, context?: any): ChainedArray; ->sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75)) + sortBy(iterator: Iterator_, context?: any): ChainedArray; +>sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 75), Decl(underscoreTest1_underscore.ts, 361, 76)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 361, 15)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 361, 42)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 361, 43)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) sortBy(propertyName: string): ChainedArray; ->sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75)) +>sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 75), Decl(underscoreTest1_underscore.ts, 361, 76)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 362, 15)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; ->groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86)) + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 87)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 364, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 364, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 364, 45)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) groupBy(propertyName: string): ChainedDictionary; ->groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86)) +>groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 87)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 365, 16)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) - countBy(iterator?: Iterator, context?: any): ChainedDictionary; ->countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87)) + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 88)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 366, 16)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 366, 44)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 366, 45)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) countBy(propertyName: string): ChainedDictionary; ->countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87)) +>countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 88)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 367, 16)) >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5)) @@ -3373,104 +3373,104 @@ module Underscore { >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 395, 14)) - each(list: T[], iterator: Iterator, context?: any): void; ->each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) + each(list: T[], iterator: Iterator_, context?: any): void; +>each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 397, 16)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 397, 26)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 397, 55)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 397, 56)) - each(list: Dictionary, iterator: Iterator, context?: any): void; ->each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) + each(list: Dictionary, iterator: Iterator_, context?: any): void; +>each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 78)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 398, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 398, 36)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 398, 65)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 398, 66)) - forEach(list: T[], iterator: Iterator, context?: any): void; ->forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 87), Decl(underscoreTest1_underscore.ts, 399, 80)) + forEach(list: T[], iterator: Iterator_, context?: any): void; +>forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 88), Decl(underscoreTest1_underscore.ts, 399, 81)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 399, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 399, 29)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 399, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 399, 59)) - forEach(list: Dictionary, iterator: Iterator, context?: any): void; ->forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 87), Decl(underscoreTest1_underscore.ts, 399, 80)) + forEach(list: Dictionary, iterator: Iterator_, context?: any): void; +>forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 88), Decl(underscoreTest1_underscore.ts, 399, 81)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 400, 19)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 400, 39)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 400, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 400, 69)) - map(list: T[], iterator: Iterator, context?: any): U[]; ->map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) + map(list: T[], iterator: Iterator_, context?: any): U[]; +>map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 402, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 402, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 402, 54)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 402, 55)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14)) - map(list: Dictionary, iterator: Iterator, context?: any): U[]; ->map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) + map(list: Dictionary, iterator: Iterator_, context?: any): U[]; +>map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 91), Decl(underscoreTest1_underscore.ts, 402, 76)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 403, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 403, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 403, 64)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 403, 65)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14)) - collect(list: T[], iterator: Iterator, context?: any): U[]; ->collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 85), Decl(underscoreTest1_underscore.ts, 404, 79)) + collect(list: T[], iterator: Iterator_, context?: any): U[]; +>collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 86), Decl(underscoreTest1_underscore.ts, 404, 80)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 404, 22)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 404, 32)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 404, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 404, 59)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18)) - collect(list: Dictionary, iterator: Iterator, context?: any): U[]; ->collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 85), Decl(underscoreTest1_underscore.ts, 404, 79)) + collect(list: Dictionary, iterator: Iterator_, context?: any): U[]; +>collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 86), Decl(underscoreTest1_underscore.ts, 404, 80)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 405, 22)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 405, 42)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 405, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 405, 69)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18)) reduce(list: T[], iterator: Reducer, initialValue?: T, context?: any): T; ->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 407, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15)) @@ -3484,7 +3484,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15)) reduce(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 408, 21)) @@ -3499,7 +3499,7 @@ module Underscore { >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17)) reduce(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 409, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -3514,7 +3514,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15)) reduce(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) +>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 90), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 15)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 410, 17)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 410, 21)) @@ -3769,100 +3769,100 @@ module Underscore { >context : Symbol(context, Decl(underscoreTest1_underscore.ts, 427, 82)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 427, 16)) - find(list: T[], iterator: Iterator, context?: any): T; ->find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77)) + find(list: T[], iterator: Iterator_, context?: any): T; +>find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 78)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 429, 16)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 429, 26)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 429, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 429, 59)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13)) - find(list: Dictionary, iterator: Iterator, context?: any): T; ->find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77)) + find(list: Dictionary, iterator: Iterator_, context?: any): T; +>find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 78)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 430, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 430, 36)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 430, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 430, 69)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13)) - detect(list: T[], iterator: Iterator, context?: any): T; ->detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 87), Decl(underscoreTest1_underscore.ts, 431, 79)) + detect(list: T[], iterator: Iterator_, context?: any): T; +>detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 88), Decl(underscoreTest1_underscore.ts, 431, 80)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 431, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 431, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 431, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 431, 61)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15)) - detect(list: Dictionary, iterator: Iterator, context?: any): T; ->detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 87), Decl(underscoreTest1_underscore.ts, 431, 79)) + detect(list: Dictionary, iterator: Iterator_, context?: any): T; +>detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 88), Decl(underscoreTest1_underscore.ts, 431, 80)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 432, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 432, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 432, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 432, 71)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15)) - filter(list: T[], iterator: Iterator, context?: any): T[]; ->filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81)) + filter(list: T[], iterator: Iterator_, context?: any): T[]; +>filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 90), Decl(underscoreTest1_underscore.ts, 434, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 434, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 434, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 434, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 434, 61)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15)) - filter(list: Dictionary, iterator: Iterator, context?: any): T[]; ->filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81)) + filter(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 90), Decl(underscoreTest1_underscore.ts, 434, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 435, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 435, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 435, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 435, 71)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15)) - select(list: T[], iterator: Iterator, context?: any): T[]; ->select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 91), Decl(underscoreTest1_underscore.ts, 436, 81)) + select(list: T[], iterator: Iterator_, context?: any): T[]; +>select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 92), Decl(underscoreTest1_underscore.ts, 436, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 436, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 436, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 436, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 436, 61)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15)) - select(list: Dictionary, iterator: Iterator, context?: any): T[]; ->select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 91), Decl(underscoreTest1_underscore.ts, 436, 81)) + select(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 92), Decl(underscoreTest1_underscore.ts, 436, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 437, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 437, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 437, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 437, 71)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15)) where(list: T[], properties: Object): T[]; ->where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53)) +>where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 92), Decl(underscoreTest1_underscore.ts, 439, 53)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 439, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14)) @@ -3871,7 +3871,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14)) where(list: Dictionary, properties: Object): T[]; ->where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53)) +>where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 92), Decl(underscoreTest1_underscore.ts, 439, 53)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 440, 17)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -3899,115 +3899,115 @@ module Underscore { >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18)) - reject(list: T[], iterator: Iterator, context?: any): T[]; ->reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81)) + reject(list: T[], iterator: Iterator_, context?: any): T[]; +>reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 445, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 445, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 445, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 445, 61)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15)) - reject(list: Dictionary, iterator: Iterator, context?: any): T[]; ->reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81)) + reject(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 82)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 446, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 446, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 446, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 446, 71)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15)) - every(list: T[], iterator?: Iterator, context?: any): boolean; ->every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 91), Decl(underscoreTest1_underscore.ts, 448, 85)) + every(list: T[], iterator?: Iterator_, context?: any): boolean; +>every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 92), Decl(underscoreTest1_underscore.ts, 448, 86)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 448, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 448, 27)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 448, 60)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 448, 61)) - every(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 91), Decl(underscoreTest1_underscore.ts, 448, 85)) + every(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 92), Decl(underscoreTest1_underscore.ts, 448, 86)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 449, 17)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 449, 37)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 449, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 449, 71)) - all(list: T[], iterator?: Iterator, context?: any): boolean; ->all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83)) + all(list: T[], iterator?: Iterator_, context?: any): boolean; +>all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 96), Decl(underscoreTest1_underscore.ts, 450, 84)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 450, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 450, 25)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 450, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 450, 59)) - all(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83)) + all(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 96), Decl(underscoreTest1_underscore.ts, 450, 84)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 451, 15)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 451, 35)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 451, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 451, 69)) - some(list: T[], iterator?: Iterator, context?: any): boolean; ->some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 93), Decl(underscoreTest1_underscore.ts, 453, 84)) + some(list: T[], iterator?: Iterator_, context?: any): boolean; +>some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 94), Decl(underscoreTest1_underscore.ts, 453, 85)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 453, 16)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 453, 26)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 453, 59)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 453, 60)) - some(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 93), Decl(underscoreTest1_underscore.ts, 453, 84)) + some(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 94), Decl(underscoreTest1_underscore.ts, 453, 85)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 454, 16)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 454, 36)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 454, 69)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 454, 70)) - any(list: T[], iterator?: Iterator, context?: any): boolean; ->any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83)) + any(list: T[], iterator?: Iterator_, context?: any): boolean; +>any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 95), Decl(underscoreTest1_underscore.ts, 455, 84)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 455, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 455, 25)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 455, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 455, 59)) - any(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83)) + any(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 95), Decl(underscoreTest1_underscore.ts, 455, 84)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 456, 15)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 456, 35)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 456, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 456, 69)) contains(list: T[], value: T): boolean; ->contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50)) +>contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 94), Decl(underscoreTest1_underscore.ts, 458, 50)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 458, 20)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17)) @@ -4015,7 +4015,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17)) contains(list: Dictionary, value: T): boolean; ->contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50)) +>contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 94), Decl(underscoreTest1_underscore.ts, 458, 50)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 459, 17)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 459, 20)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -4064,77 +4064,77 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 467, 36)) - max(list: T[], iterator?: Iterator, context?: any): T; ->max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73)) + max(list: T[], iterator?: Iterator_, context?: any): T; +>max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 74)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 469, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 469, 25)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 469, 54)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 469, 55)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12)) - max(list: Dictionary, iterator?: Iterator, context?: any): T; ->max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73)) + max(list: Dictionary, iterator?: Iterator_, context?: any): T; +>max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 74)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 470, 15)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 470, 35)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 470, 64)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 470, 65)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12)) - min(list: T[], iterator?: Iterator, context?: any): T; ->min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73)) + min(list: T[], iterator?: Iterator_, context?: any): T; +>min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 84), Decl(underscoreTest1_underscore.ts, 472, 74)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 472, 15)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 472, 25)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 472, 54)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 472, 55)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12)) - min(list: Dictionary, iterator?: Iterator, context?: any): T; ->min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73)) + min(list: Dictionary, iterator?: Iterator_, context?: any): T; +>min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 84), Decl(underscoreTest1_underscore.ts, 472, 74)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 473, 15)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 473, 35)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 473, 64)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 473, 65)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12)) - sortBy(list: T[], iterator: Iterator, context?: any): T[]; ->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) + sortBy(list: T[], iterator: Iterator_, context?: any): T[]; +>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 475, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 475, 28)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 475, 56)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 475, 57)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15)) - sortBy(list: Dictionary, iterator: Iterator, context?: any): T[]; ->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) + sortBy(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 476, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 476, 38)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 476, 66)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 476, 67)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15)) sortBy(list: T[], propertyName: string): T[]; ->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) +>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 477, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15)) @@ -4142,7 +4142,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15)) sortBy(list: Dictionary, propertyName: string): T[]; ->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) +>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 84), Decl(underscoreTest1_underscore.ts, 475, 78), Decl(underscoreTest1_underscore.ts, 476, 88), Decl(underscoreTest1_underscore.ts, 477, 56)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 478, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 478, 18)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -4150,33 +4150,33 @@ module Underscore { >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 478, 38)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 478, 15)) - groupBy(list: T[], iterator?: Iterator, context?: any): Dictionary; ->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) + groupBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; +>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 480, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 480, 29)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 480, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 480, 59)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16)) - groupBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; ->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) + groupBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; +>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 481, 19)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 481, 39)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 481, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 481, 69)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16)) groupBy(list: T[], propertyName: string): Dictionary; ->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 482, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16)) @@ -4185,7 +4185,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16)) groupBy(list: Dictionary, propertyName: string): Dictionary; ->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) +>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 92), Decl(underscoreTest1_underscore.ts, 481, 102), Decl(underscoreTest1_underscore.ts, 482, 69)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 483, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 483, 19)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -4194,31 +4194,31 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 483, 16)) - countBy(list: T[], iterator?: Iterator, context?: any): Dictionary; ->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) + countBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; +>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 485, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 485, 29)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 485, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 485, 59)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) - countBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; ->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) + countBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; +>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 486, 19)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 486, 39)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 486, 68)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 486, 69)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) countBy(list: T[], propertyName: string): Dictionary; ->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) +>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 487, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16)) @@ -4226,7 +4226,7 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) countBy(list: Dictionary, propertyName: string): Dictionary; ->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72)) +>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 95), Decl(underscoreTest1_underscore.ts, 486, 105), Decl(underscoreTest1_underscore.ts, 487, 72)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 488, 16)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 488, 19)) >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) @@ -4421,7 +4421,7 @@ module Underscore { >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 527, 26)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 527, 13)) - uniq(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; >uniq : Symbol(Static.uniq, Decl(underscoreTest1_underscore.ts, 525, 56), Decl(underscoreTest1_underscore.ts, 527, 52)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15)) @@ -4429,36 +4429,36 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 528, 29)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 528, 48)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 528, 74)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 528, 75)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15)) unique(list: T[], isSorted?: boolean): T[]; ->unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 95), Decl(underscoreTest1_underscore.ts, 529, 54)) +>unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 96), Decl(underscoreTest1_underscore.ts, 529, 54)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 529, 18)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 529, 28)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15)) - unique(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; ->unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 95), Decl(underscoreTest1_underscore.ts, 529, 54)) + unique(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 96), Decl(underscoreTest1_underscore.ts, 529, 54)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 530, 21)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15)) >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 530, 31)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 530, 50)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 530, 76)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 530, 77)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17)) zip(a0: T0[], a1: T1[]): Tuple2[]; ->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 532, 12)) >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15)) >a0 : Symbol(a0, Decl(underscoreTest1_underscore.ts, 532, 20)) @@ -4470,7 +4470,7 @@ module Underscore { >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15)) zip(a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; ->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 533, 12)) >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 533, 15)) >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19)) @@ -4486,7 +4486,7 @@ module Underscore { >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19)) zip(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4[]; ->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 534, 12)) >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 534, 15)) >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 534, 19)) @@ -4506,7 +4506,7 @@ module Underscore { >T3 : Symbol(T3, Decl(underscoreTest1_underscore.ts, 534, 23)) zip(...arrays: any[][]): any[][]; ->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) +>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 98), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94)) >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 535, 12)) object(list: any[][]): any; @@ -4545,7 +4545,7 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20)) >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 544, 41)) - sortedIndex(list: T[], obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(list: T[], obj: T, iterator?: Iterator_, context?: any): number; >sortedIndex : Symbol(Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 542, 72), Decl(underscoreTest1_underscore.ts, 544, 72)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20)) >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 545, 23)) @@ -4553,16 +4553,16 @@ module Underscore { >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 545, 33)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 545, 41)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 545, 70)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 545, 71)) range(stop: number): number[]; ->range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >stop : Symbol(stop, Decl(underscoreTest1_underscore.ts, 547, 14)) range(start: number, stop: number, step?: number): number[]; ->range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38)) +>range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 95), Decl(underscoreTest1_underscore.ts, 547, 38)) >start : Symbol(start, Decl(underscoreTest1_underscore.ts, 548, 14)) >stop : Symbol(stop, Decl(underscoreTest1_underscore.ts, 548, 28)) >step : Symbol(step, Decl(underscoreTest1_underscore.ts, 548, 42)) @@ -4833,22 +4833,22 @@ module Underscore { >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 620, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 620, 17)) - times(n: number, iterator: Iterator, context?: any): U[]; + times(n: number, iterator: Iterator_, context?: any): U[]; >times : Symbol(Static.times, Decl(underscoreTest1_underscore.ts, 620, 33)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14)) >n : Symbol(n, Decl(underscoreTest1_underscore.ts, 622, 17)) >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 622, 27)) ->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1)) +>Iterator_ : Symbol(Iterator_, Decl(underscoreTest1_underscore.ts, 2, 1)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14)) ->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 622, 58)) +>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 622, 59)) >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14)) random(max: number): number; ->random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36)) +>random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 80), Decl(underscoreTest1_underscore.ts, 624, 36)) >max : Symbol(max, Decl(underscoreTest1_underscore.ts, 624, 15)) random(min: number, max: number): number; ->random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36)) +>random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 80), Decl(underscoreTest1_underscore.ts, 624, 36)) >min : Symbol(min, Decl(underscoreTest1_underscore.ts, 625, 15)) >max : Symbol(max, Decl(underscoreTest1_underscore.ts, 625, 27)) diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types index 97e064fb12c45..afcc807b756bd 100644 --- a/tests/baselines/reference/underscoreTest1.types +++ b/tests/baselines/reference/underscoreTest1.types @@ -10,9 +10,9 @@ declare function alert(x: string): void; _.each([1, 2, 3], (num) => alert(num.toString())); >_.each([1, 2, 3], (num) => alert(num.toString())) : void ->_.each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>_.each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >_ : Underscore.Static ->each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 @@ -28,9 +28,9 @@ _.each([1, 2, 3], (num) => alert(num.toString())); _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())); >_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())) : void ->_.each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>_.each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >_ : Underscore.Static ->each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; } >one : number >1 : 1 @@ -50,9 +50,9 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu _.map([1, 2, 3], (num) => num * 3); >_.map([1, 2, 3], (num) => num * 3) : number[] ->_.map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } +>_.map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >_ : Underscore.Static ->map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } +>map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 @@ -65,9 +65,9 @@ _.map([1, 2, 3], (num) => num * 3); _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3); >_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3) : number[] ->_.map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } +>_.map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >_ : Underscore.Static ->map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } +>map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; } >one : number >1 : 1 @@ -133,9 +133,9 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []); var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >even : number >_.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number ->_.find : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } +>_.find : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >_ : Underscore.Static ->find : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } +>find : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >[1, 2, 3, 4, 5, 6] : number[] >1 : 1 >2 : 2 @@ -154,9 +154,9 @@ var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >evens : number[] >_.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[] ->_.filter : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } +>_.filter : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >_ : Underscore.Static ->filter : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } +>filter : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >[1, 2, 3, 4, 5, 6] : number[] >1 : 1 >2 : 2 @@ -212,9 +212,9 @@ _.where(listOfPlays, { author: "Shakespeare", year: 1611 }); var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); >odds : number[] >_.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[] ->_.reject : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } +>_.reject : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >_ : Underscore.Static ->reject : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } +>reject : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >[1, 2, 3, 4, 5, 6] : number[] >1 : 1 >2 : 2 @@ -232,9 +232,9 @@ var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); _.all([true, 1, null, 'yes'], _.identity); >_.all([true, 1, null, 'yes'], _.identity) : boolean ->_.all : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } +>_.all : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >_ : Underscore.Static ->all : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } +>all : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >[true, 1, null, 'yes'] : (true | 1 | "yes")[] >true : true >1 : 1 @@ -246,9 +246,9 @@ _.all([true, 1, null, 'yes'], _.identity); _.any([null, 0, 'yes', false]); >_.any([null, 0, 'yes', false]) : boolean ->_.any : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } +>_.any : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >_ : Underscore.Static ->any : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } +>any : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >[null, 0, 'yes', false] : (false | 0 | "yes")[] >null : null >0 : 0 @@ -311,9 +311,9 @@ _.pluck(stooges, 'name'); _.max(stooges, (stooge) => stooge.age); >_.max(stooges, (stooge) => stooge.age) : { name: string; age: number; } ->_.max : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } +>_.max : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >_ : Underscore.Static ->max : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } +>max : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >stooges : { name: string; age: number; }[] >(stooge) => stooge.age : (stooge: { name: string; age: number; }) => number >stooge : { name: string; age: number; } @@ -332,16 +332,16 @@ var numbers = [10, 5, 100, 2, 1000]; _.min(numbers); >_.min(numbers) : number ->_.min : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } +>_.min : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >_ : Underscore.Static ->min : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } +>min : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >numbers : number[] _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); >_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)) : number[] ->_.sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } +>_.sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >_ : Underscore.Static ->sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } +>sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >[1, 2, 3, 4, 5, 6] : number[] >1 : 1 >2 : 2 @@ -361,14 +361,14 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); // not sure how this is typechecking at all.. Math.floor(e) is number not string..? _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)); >_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)) : Dictionary ->_([1.3, 2.1, 2.4]).groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>_([1.3, 2.1, 2.4]).groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >_([1.3, 2.1, 2.4]) : Underscore.WrappedArray >_ : Underscore.Static >[1.3, 2.1, 2.4] : number[] >1.3 : 1.3 >2.1 : 2.1 >2.4 : 2.4 ->groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >(e: number, i?: number, list?: number[]) => Math.floor(e) : (e: number, i?: number, list?: number[]) => number >e : number >i : number @@ -381,9 +381,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); >_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)) : Dictionary ->_.groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>_.groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >_ : Underscore.Static ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >[1.3, 2.1, 2.4] : number[] >1.3 : 1.3 >2.1 : 2.1 @@ -398,9 +398,9 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); _.groupBy(['one', 'two', 'three'], 'length'); >_.groupBy(['one', 'two', 'three'], 'length') : Dictionary ->_.groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>_.groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >_ : Underscore.Static ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >['one', 'two', 'three'] : string[] >'one' : "one" >'two' : "two" @@ -409,9 +409,9 @@ _.groupBy(['one', 'two', 'three'], 'length'); _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd'); >_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd') : Dictionary ->_.countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>_.countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >_ : Underscore.Static ->countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >[1, 2, 3, 4, 5] : number[] >1 : 1 >2 : 2 @@ -643,9 +643,9 @@ _.difference([1, 2, 3, 4, 5], [5, 2, 10]); _.uniq([1, 2, 1, 3, 1, 4]); >_.uniq([1, 2, 1, 3, 1, 4]) : number[] ->_.uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>_.uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >_ : Underscore.Static ->uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >[1, 2, 1, 3, 1, 4] : number[] >1 : 1 >2 : 2 @@ -729,9 +729,9 @@ _.lastIndexOf([1, 2, 3, 1, 2, 3], 2); _.sortedIndex([10, 20, 30, 40, 50], 35); >_.sortedIndex([10, 20, 30, 40, 50], 35) : number ->_.sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator, context?: any): number; } +>_.sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } >_ : Underscore.Static ->sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator, context?: any): number; } +>sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } >[10, 20, 30, 40, 50] : number[] >10 : 10 >20 : 20 @@ -1017,9 +1017,9 @@ var renderNotes = _.after(notes.length, render); _.each(notes, (note) => note.asyncSave({ success: renderNotes })); >_.each(notes, (note) => note.asyncSave({ success: renderNotes })) : void ->_.each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>_.each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >_ : Underscore.Static ->each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } +>each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >notes : any[] >(note) => note.asyncSave({ success: renderNotes }) : (note: any) => any >note : any @@ -1226,11 +1226,11 @@ _.chain([1, 2, 3, 200]) >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map(function (num) { return num * num }) .value() : number[] >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map(function (num) { return num * num }) .value : () => number[] >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map(function (num) { return num * num }) : Underscore.ChainedArray ->_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map : (iterator: Iterator, context?: any) => Underscore.ChainedArray +>_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) .map : (iterator: Iterator_, context?: any) => Underscore.ChainedArray >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap(alert) : Underscore.ChainedArray >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) .tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray >_.chain([1, 2, 3, 200]) .filter(function (num) { return num % 2 == 0; }) : Underscore.ChainedArray ->_.chain([1, 2, 3, 200]) .filter : (iterator: Iterator, context?: any) => Underscore.ChainedArray +>_.chain([1, 2, 3, 200]) .filter : (iterator: Iterator_, context?: any) => Underscore.ChainedArray >_.chain([1, 2, 3, 200]) : Underscore.ChainedArray >_.chain : { (list: T[]): Underscore.ChainedArray; (list: Dictionary): Underscore.ChainedDictionary; (obj: T): Underscore.ChainedObject; } >_ : Underscore.Static @@ -1242,7 +1242,7 @@ _.chain([1, 2, 3, 200]) >200 : 200 .filter(function (num) { return num % 2 == 0; }) ->filter : (iterator: Iterator, context?: any) => Underscore.ChainedArray +>filter : (iterator: Iterator_, context?: any) => Underscore.ChainedArray >function (num) { return num % 2 == 0; } : (num: number) => boolean >num : number >num % 2 == 0 : boolean @@ -1257,7 +1257,7 @@ _.chain([1, 2, 3, 200]) >alert : (x: string) => void .map(function (num) { return num * num }) ->map : (iterator: Iterator, context?: any) => Underscore.ChainedArray +>map : (iterator: Iterator_, context?: any) => Underscore.ChainedArray >function (num) { return num * num } : (num: number) => number >num : number >num * num : number @@ -1524,9 +1524,9 @@ var genie; _.times(3, function (n) { genie.grantWishNumber(n); }); >_.times(3, function (n) { genie.grantWishNumber(n); }) : void[] ->_.times : (n: number, iterator: Iterator, context?: any) => U[] +>_.times : (n: number, iterator: Iterator_, context?: any) => U[] >_ : Underscore.Static ->times : (n: number, iterator: Iterator, context?: any) => U[] +>times : (n: number, iterator: Iterator_, context?: any) => U[] >3 : 3 >function (n) { genie.grantWishNumber(n); } : (n: number) => void >n : number @@ -1737,8 +1737,8 @@ interface Dictionary { >T : T } -interface Iterator { ->Iterator : Iterator +interface Iterator_ { +>Iterator_ : Iterator_ >T : T >U : U @@ -2011,35 +2011,35 @@ module Underscore { >Array : T[] >T : T - each(iterator: Iterator, context?: any): void; ->each : (iterator: Iterator, context?: any) => void ->iterator : Iterator ->Iterator : Iterator + each(iterator: Iterator_, context?: any): void; +>each : (iterator: Iterator_, context?: any) => void +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - forEach(iterator: Iterator, context?: any): void; ->forEach : (iterator: Iterator, context?: any) => void ->iterator : Iterator ->Iterator : Iterator + forEach(iterator: Iterator_, context?: any): void; +>forEach : (iterator: Iterator_, context?: any) => void +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - map(iterator: Iterator, context?: any): U[]; ->map : (iterator: Iterator, context?: any) => U[] + map(iterator: Iterator_, context?: any): U[]; +>map : (iterator: Iterator_, context?: any) => U[] >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U - collect(iterator: Iterator, context?: any): U[]; ->collect : (iterator: Iterator, context?: any) => U[] + collect(iterator: Iterator_, context?: any): U[]; +>collect : (iterator: Iterator_, context?: any) => U[] >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -2160,34 +2160,34 @@ module Underscore { >context : any >U : U - find(iterator: Iterator, context?: any): T; ->find : (iterator: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + find(iterator: Iterator_, context?: any): T; +>find : (iterator: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - detect(iterator: Iterator, context?: any): T; ->detect : (iterator: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + detect(iterator: Iterator_, context?: any): T; +>detect : (iterator: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - filter(iterator: Iterator, context?: any): T[]; ->filter : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + filter(iterator: Iterator_, context?: any): T[]; +>filter : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - select(iterator: Iterator, context?: any): T[]; ->select : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + select(iterator: Iterator_, context?: any): T[]; +>select : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T @@ -2204,39 +2204,39 @@ module Underscore { >Object : Object >T : T - reject(iterator: Iterator, context?: any): T[]; ->reject : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + reject(iterator: Iterator_, context?: any): T[]; +>reject : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - every(iterator?: Iterator, context?: any): boolean; ->every : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + every(iterator?: Iterator_, context?: any): boolean; +>every : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - all(iterator?: Iterator, context?: any): boolean; ->all : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + all(iterator?: Iterator_, context?: any): boolean; +>all : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - some(iterator?: Iterator, context?: any): boolean; ->some : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + some(iterator?: Iterator_, context?: any): boolean; +>some : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - any(iterator?: Iterator, context?: any): boolean; ->any : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + any(iterator?: Iterator_, context?: any): boolean; +>any : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any @@ -2259,60 +2259,60 @@ module Underscore { >pluck : (propertyName: string) => any[] >propertyName : string - max(iterator?: Iterator, context?: any): T; ->max : (iterator?: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + max(iterator?: Iterator_, context?: any): T; +>max : (iterator?: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - min(iterator?: Iterator, context?: any): T; ->min : (iterator?: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + min(iterator?: Iterator_, context?: any): T; +>min : (iterator?: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - sortBy(iterator: Iterator, context?: any): T[]; ->sortBy : { (iterator: Iterator, context?: any): T[]; (propertyName: string): T[]; } ->iterator : Iterator ->Iterator : Iterator + sortBy(iterator: Iterator_, context?: any): T[]; +>sortBy : { (iterator: Iterator_, context?: any): T[]; (propertyName: string): T[]; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T sortBy(propertyName: string): T[]; ->sortBy : { (iterator: Iterator, context?: any): T[]; (propertyName: string): T[]; } +>sortBy : { (iterator: Iterator_, context?: any): T[]; (propertyName: string): T[]; } >propertyName : string >T : T - groupBy(iterator?: Iterator, context?: any): Dictionary; ->groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } ->iterator : Iterator ->Iterator : Iterator + groupBy(iterator?: Iterator_, context?: any): Dictionary; +>groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary >T : T groupBy(propertyName: string): Dictionary; ->groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >propertyName : string >Dictionary : Dictionary >T : T - countBy(iterator?: Iterator, context?: any): Dictionary; ->countBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } ->iterator : Iterator ->Iterator : Iterator + countBy(iterator?: Iterator_, context?: any): Dictionary; +>countBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary countBy(propertyName: string): Dictionary; ->countBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>countBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >propertyName : string >Dictionary : Dictionary @@ -2412,32 +2412,32 @@ module Underscore { >T : T uniq(isSorted?: boolean): T[]; ->uniq : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>uniq : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >isSorted : boolean >T : T - uniq(isSorted: boolean, iterator: Iterator, context?: any): U[]; ->uniq : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator, context?: any): U[]; } + uniq(isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>uniq : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >U : U >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U unique(isSorted?: boolean): T[]; ->unique : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>unique : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >isSorted : boolean >T : T - unique(isSorted: boolean, iterator: Iterator, context?: any): U[]; ->unique : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator, context?: any): U[]; } + unique(isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>unique : { (isSorted?: boolean): T[]; (isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >U : U >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -2467,17 +2467,17 @@ module Underscore { >fromIndex : number sortedIndex(obj: T, propertyName: string): number; ->sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator, context?: any): number; } +>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator_, context?: any): number; } >obj : T >T : T >propertyName : string - sortedIndex(obj: T, iterator?: Iterator, context?: any): number; ->sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator, context?: any): number; } + sortedIndex(obj: T, iterator?: Iterator_, context?: any): number; +>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator_, context?: any): number; } >obj : T >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any @@ -2550,35 +2550,35 @@ module Underscore { >Dictionary : Dictionary >T : T - each(iterator: Iterator, context?: any): void; ->each : (iterator: Iterator, context?: any) => void ->iterator : Iterator ->Iterator : Iterator + each(iterator: Iterator_, context?: any): void; +>each : (iterator: Iterator_, context?: any) => void +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - forEach(iterator: Iterator, context?: any): void; ->forEach : (iterator: Iterator, context?: any) => void ->iterator : Iterator ->Iterator : Iterator + forEach(iterator: Iterator_, context?: any): void; +>forEach : (iterator: Iterator_, context?: any) => void +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - map(iterator: Iterator, context?: any): U[]; ->map : (iterator: Iterator, context?: any) => U[] + map(iterator: Iterator_, context?: any): U[]; +>map : (iterator: Iterator_, context?: any) => U[] >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U - collect(iterator: Iterator, context?: any): U[]; ->collect : (iterator: Iterator, context?: any) => U[] + collect(iterator: Iterator_, context?: any): U[]; +>collect : (iterator: Iterator_, context?: any) => U[] >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -2699,34 +2699,34 @@ module Underscore { >context : any >U : U - find(iterator: Iterator, context?: any): T; ->find : (iterator: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + find(iterator: Iterator_, context?: any): T; +>find : (iterator: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - detect(iterator: Iterator, context?: any): T; ->detect : (iterator: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + detect(iterator: Iterator_, context?: any): T; +>detect : (iterator: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - filter(iterator: Iterator, context?: any): T[]; ->filter : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + filter(iterator: Iterator_, context?: any): T[]; +>filter : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - select(iterator: Iterator, context?: any): T[]; ->select : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + select(iterator: Iterator_, context?: any): T[]; +>select : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T @@ -2743,39 +2743,39 @@ module Underscore { >Object : Object >T : T - reject(iterator: Iterator, context?: any): T[]; ->reject : (iterator: Iterator, context?: any) => T[] ->iterator : Iterator ->Iterator : Iterator + reject(iterator: Iterator_, context?: any): T[]; +>reject : (iterator: Iterator_, context?: any) => T[] +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - every(iterator?: Iterator, context?: any): boolean; ->every : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + every(iterator?: Iterator_, context?: any): boolean; +>every : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - all(iterator?: Iterator, context?: any): boolean; ->all : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + all(iterator?: Iterator_, context?: any): boolean; +>all : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - some(iterator?: Iterator, context?: any): boolean; ->some : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + some(iterator?: Iterator_, context?: any): boolean; +>some : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - any(iterator?: Iterator, context?: any): boolean; ->any : (iterator?: Iterator, context?: any) => boolean ->iterator : Iterator ->Iterator : Iterator + any(iterator?: Iterator_, context?: any): boolean; +>any : (iterator?: Iterator_, context?: any) => boolean +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any @@ -2798,60 +2798,60 @@ module Underscore { >pluck : (propertyName: string) => any[] >propertyName : string - max(iterator?: Iterator, context?: any): T; ->max : (iterator?: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + max(iterator?: Iterator_, context?: any): T; +>max : (iterator?: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - min(iterator?: Iterator, context?: any): T; ->min : (iterator?: Iterator, context?: any) => T ->iterator : Iterator ->Iterator : Iterator + min(iterator?: Iterator_, context?: any): T; +>min : (iterator?: Iterator_, context?: any) => T +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - sortBy(iterator: Iterator, context?: any): T[]; ->sortBy : { (iterator: Iterator, context?: any): T[]; (propertyName: string): T[]; } ->iterator : Iterator ->Iterator : Iterator + sortBy(iterator: Iterator_, context?: any): T[]; +>sortBy : { (iterator: Iterator_, context?: any): T[]; (propertyName: string): T[]; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T sortBy(propertyName: string): T[]; ->sortBy : { (iterator: Iterator, context?: any): T[]; (propertyName: string): T[]; } +>sortBy : { (iterator: Iterator_, context?: any): T[]; (propertyName: string): T[]; } >propertyName : string >T : T - groupBy(iterator?: Iterator, context?: any): Dictionary; ->groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } ->iterator : Iterator ->Iterator : Iterator + groupBy(iterator?: Iterator_, context?: any): Dictionary; +>groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary >T : T groupBy(propertyName: string): Dictionary; ->groupBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>groupBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >propertyName : string >Dictionary : Dictionary >T : T - countBy(iterator?: Iterator, context?: any): Dictionary; ->countBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } ->iterator : Iterator ->Iterator : Iterator + countBy(iterator?: Iterator_, context?: any): Dictionary; +>countBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary countBy(propertyName: string): Dictionary; ->countBy : { (iterator?: Iterator, context?: any): Dictionary; (propertyName: string): Dictionary; } +>countBy : { (iterator?: Iterator_, context?: any): Dictionary; (propertyName: string): Dictionary; } >propertyName : string >Dictionary : Dictionary @@ -3015,38 +3015,38 @@ module Underscore { >Array : T[] >T : T - each(iterator: Iterator, context?: any): ChainedObject; ->each : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + each(iterator: Iterator_, context?: any): ChainedObject; +>each : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - forEach(iterator: Iterator, context?: any): ChainedObject; ->forEach : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + forEach(iterator: Iterator_, context?: any): ChainedObject; +>forEach : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - map(iterator: Iterator, context?: any): ChainedArray; ->map : (iterator: Iterator, context?: any) => ChainedArray + map(iterator: Iterator_, context?: any): ChainedArray; +>map : (iterator: Iterator_, context?: any) => ChainedArray >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >ChainedArray : ChainedArray >U : U - collect(iterator: Iterator, context?: any): ChainedArray; ->collect : (iterator: Iterator, context?: any) => ChainedArray + collect(iterator: Iterator_, context?: any): ChainedArray; +>collect : (iterator: Iterator_, context?: any) => ChainedArray >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -3178,37 +3178,37 @@ module Underscore { >ChainedObject : ChainedObject >U : U - find(iterator: Iterator, context?: any): ChainedObject; ->find : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + find(iterator: Iterator_, context?: any): ChainedObject; +>find : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - detect(iterator: Iterator, context?: any): ChainedObject; ->detect : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + detect(iterator: Iterator_, context?: any): ChainedObject; +>detect : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - filter(iterator: Iterator, context?: any): ChainedArray; ->filter : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + filter(iterator: Iterator_, context?: any): ChainedArray; +>filter : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T - select(iterator: Iterator, context?: any): ChainedArray; ->select : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + select(iterator: Iterator_, context?: any): ChainedArray; +>select : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray @@ -3228,43 +3228,43 @@ module Underscore { >ChainedObject : ChainedObject >T : T - reject(iterator: Iterator, context?: any): ChainedArray; ->reject : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + reject(iterator: Iterator_, context?: any): ChainedArray; +>reject : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T - every(iterator?: Iterator, context?: any): ChainedObject; ->every : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + every(iterator?: Iterator_, context?: any): ChainedObject; +>every : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - all(iterator?: Iterator, context?: any): ChainedObject; ->all : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + all(iterator?: Iterator_, context?: any): ChainedObject; +>all : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - some(iterator?: Iterator, context?: any): ChainedObject; ->some : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + some(iterator?: Iterator_, context?: any): ChainedObject; +>some : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - any(iterator?: Iterator, context?: any): ChainedObject; ->any : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + any(iterator?: Iterator_, context?: any): ChainedObject; +>any : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject @@ -3292,63 +3292,63 @@ module Underscore { >propertyName : string >ChainedArray : ChainedArray - max(iterator?: Iterator, context?: any): ChainedObject; ->max : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + max(iterator?: Iterator_, context?: any): ChainedObject; +>max : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - min(iterator?: Iterator, context?: any): ChainedObject; ->min : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + min(iterator?: Iterator_, context?: any): ChainedObject; +>min : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - sortBy(iterator: Iterator, context?: any): ChainedArray; ->sortBy : { (iterator: Iterator, context?: any): ChainedArray; (propertyName: string): ChainedArray; } ->iterator : Iterator ->Iterator : Iterator + sortBy(iterator: Iterator_, context?: any): ChainedArray; +>sortBy : { (iterator: Iterator_, context?: any): ChainedArray; (propertyName: string): ChainedArray; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T sortBy(propertyName: string): ChainedArray; ->sortBy : { (iterator: Iterator, context?: any): ChainedArray; (propertyName: string): ChainedArray; } +>sortBy : { (iterator: Iterator_, context?: any): ChainedArray; (propertyName: string): ChainedArray; } >propertyName : string >ChainedArray : ChainedArray >T : T // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; ->groupBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } ->iterator : Iterator ->Iterator : Iterator + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>groupBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedDictionary : ChainedDictionary groupBy(propertyName: string): ChainedDictionary; ->groupBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>groupBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } >propertyName : string >ChainedDictionary : ChainedDictionary - countBy(iterator?: Iterator, context?: any): ChainedDictionary; ->countBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } ->iterator : Iterator ->Iterator : Iterator + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>countBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedDictionary : ChainedDictionary countBy(propertyName: string): ChainedDictionary; ->countBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>countBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } >propertyName : string >ChainedDictionary : ChainedDictionary @@ -3468,17 +3468,17 @@ module Underscore { >T : T uniq(isSorted?: boolean): ChainedArray; ->uniq : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; } +>uniq : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; } >isSorted : boolean >ChainedArray : ChainedArray >T : T - uniq(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; ->uniq : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; } + uniq(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; +>uniq : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; } >U : U >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -3486,17 +3486,17 @@ module Underscore { >U : U unique(isSorted?: boolean): ChainedArray; ->unique : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; } +>unique : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; } >isSorted : boolean >ChainedArray : ChainedArray >T : T - unique(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; ->unique : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; } + unique(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; +>unique : { (isSorted?: boolean): ChainedArray; (isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; } >U : U >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -3532,18 +3532,18 @@ module Underscore { >ChainedObject : ChainedObject sortedIndex(obj: T, propertyName: string): ChainedObject; ->sortedIndex : { (obj: T, propertyName: string): ChainedObject; (obj: T, iterator?: Iterator, context?: any): ChainedObject; } +>sortedIndex : { (obj: T, propertyName: string): ChainedObject; (obj: T, iterator?: Iterator_, context?: any): ChainedObject; } >obj : T >T : T >propertyName : string >ChainedObject : ChainedObject - sortedIndex(obj: T, iterator?: Iterator, context?: any): ChainedObject; ->sortedIndex : { (obj: T, propertyName: string): ChainedObject; (obj: T, iterator?: Iterator, context?: any): ChainedObject; } + sortedIndex(obj: T, iterator?: Iterator_, context?: any): ChainedObject; +>sortedIndex : { (obj: T, propertyName: string): ChainedObject; (obj: T, iterator?: Iterator_, context?: any): ChainedObject; } >obj : T >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject @@ -3666,38 +3666,38 @@ module Underscore { >Dictionary : Dictionary >T : T - each(iterator: Iterator, context?: any): ChainedObject; ->each : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + each(iterator: Iterator_, context?: any): ChainedObject; +>each : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - forEach(iterator: Iterator, context?: any): ChainedObject; ->forEach : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + forEach(iterator: Iterator_, context?: any): ChainedObject; +>forEach : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - map(iterator: Iterator, context?: any): ChainedArray; ->map : (iterator: Iterator, context?: any) => ChainedArray + map(iterator: Iterator_, context?: any): ChainedArray; +>map : (iterator: Iterator_, context?: any) => ChainedArray >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >ChainedArray : ChainedArray >U : U - collect(iterator: Iterator, context?: any): ChainedArray; ->collect : (iterator: Iterator, context?: any) => ChainedArray + collect(iterator: Iterator_, context?: any): ChainedArray; +>collect : (iterator: Iterator_, context?: any) => ChainedArray >U : U ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -3829,37 +3829,37 @@ module Underscore { >ChainedObject : ChainedObject >U : U - find(iterator: Iterator, context?: any): ChainedObject; ->find : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + find(iterator: Iterator_, context?: any): ChainedObject; +>find : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - detect(iterator: Iterator, context?: any): ChainedObject; ->detect : (iterator: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + detect(iterator: Iterator_, context?: any): ChainedObject; +>detect : (iterator: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - filter(iterator: Iterator, context?: any): ChainedArray; ->filter : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + filter(iterator: Iterator_, context?: any): ChainedArray; +>filter : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T - select(iterator: Iterator, context?: any): ChainedArray; ->select : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + select(iterator: Iterator_, context?: any): ChainedArray; +>select : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray @@ -3879,43 +3879,43 @@ module Underscore { >ChainedObject : ChainedObject >T : T - reject(iterator: Iterator, context?: any): ChainedArray; ->reject : (iterator: Iterator, context?: any) => ChainedArray ->iterator : Iterator ->Iterator : Iterator + reject(iterator: Iterator_, context?: any): ChainedArray; +>reject : (iterator: Iterator_, context?: any) => ChainedArray +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T - every(iterator?: Iterator, context?: any): ChainedObject; ->every : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + every(iterator?: Iterator_, context?: any): ChainedObject; +>every : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - all(iterator?: Iterator, context?: any): ChainedObject; ->all : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + all(iterator?: Iterator_, context?: any): ChainedObject; +>all : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - some(iterator?: Iterator, context?: any): ChainedObject; ->some : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + some(iterator?: Iterator_, context?: any): ChainedObject; +>some : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject - any(iterator?: Iterator, context?: any): ChainedObject; ->any : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + any(iterator?: Iterator_, context?: any): ChainedObject; +>any : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject @@ -3943,63 +3943,63 @@ module Underscore { >propertyName : string >ChainedArray : ChainedArray - max(iterator?: Iterator, context?: any): ChainedObject; ->max : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + max(iterator?: Iterator_, context?: any): ChainedObject; +>max : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - min(iterator?: Iterator, context?: any): ChainedObject; ->min : (iterator?: Iterator, context?: any) => ChainedObject ->iterator : Iterator ->Iterator : Iterator + min(iterator?: Iterator_, context?: any): ChainedObject; +>min : (iterator?: Iterator_, context?: any) => ChainedObject +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedObject : ChainedObject >T : T - sortBy(iterator: Iterator, context?: any): ChainedArray; ->sortBy : { (iterator: Iterator, context?: any): ChainedArray; (propertyName: string): ChainedArray; } ->iterator : Iterator ->Iterator : Iterator + sortBy(iterator: Iterator_, context?: any): ChainedArray; +>sortBy : { (iterator: Iterator_, context?: any): ChainedArray; (propertyName: string): ChainedArray; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedArray : ChainedArray >T : T sortBy(propertyName: string): ChainedArray; ->sortBy : { (iterator: Iterator, context?: any): ChainedArray; (propertyName: string): ChainedArray; } +>sortBy : { (iterator: Iterator_, context?: any): ChainedArray; (propertyName: string): ChainedArray; } >propertyName : string >ChainedArray : ChainedArray >T : T // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; ->groupBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } ->iterator : Iterator ->Iterator : Iterator + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>groupBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedDictionary : ChainedDictionary groupBy(propertyName: string): ChainedDictionary; ->groupBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>groupBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } >propertyName : string >ChainedDictionary : ChainedDictionary - countBy(iterator?: Iterator, context?: any): ChainedDictionary; ->countBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } ->iterator : Iterator ->Iterator : Iterator + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; +>countBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >ChainedDictionary : ChainedDictionary countBy(propertyName: string): ChainedDictionary; ->countBy : { (iterator?: Iterator, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } +>countBy : { (iterator?: Iterator_, context?: any): ChainedDictionary; (propertyName: string): ChainedDictionary; } >propertyName : string >ChainedDictionary : ChainedDictionary @@ -4134,97 +4134,97 @@ module Underscore { >ChainedObject : ChainedObject >T : T - each(list: T[], iterator: Iterator, context?: any): void; ->each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } + each(list: T[], iterator: Iterator_, context?: any): void; +>each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - each(list: Dictionary, iterator: Iterator, context?: any): void; ->each : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } + each(list: Dictionary, iterator: Iterator_, context?: any): void; +>each : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - forEach(list: T[], iterator: Iterator, context?: any): void; ->forEach : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } + forEach(list: T[], iterator: Iterator_, context?: any): void; +>forEach : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - forEach(list: Dictionary, iterator: Iterator, context?: any): void; ->forEach : { (list: T[], iterator: Iterator, context?: any): void; (list: Dictionary, iterator: Iterator, context?: any): void; } + forEach(list: Dictionary, iterator: Iterator_, context?: any): void; +>forEach : { (list: T[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - map(list: T[], iterator: Iterator, context?: any): U[]; ->map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } + map(list: T[], iterator: Iterator_, context?: any): U[]; +>map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U - map(list: Dictionary, iterator: Iterator, context?: any): U[]; ->map : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } + map(list: Dictionary, iterator: Iterator_, context?: any): U[]; +>map : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U - collect(list: T[], iterator: Iterator, context?: any): U[]; ->collect : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } + collect(list: T[], iterator: Iterator_, context?: any): U[]; +>collect : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U - collect(list: Dictionary, iterator: Iterator, context?: any): U[]; ->collect : { (list: T[], iterator: Iterator, context?: any): U[]; (list: Dictionary, iterator: Iterator, context?: any): U[]; } + collect(list: Dictionary, iterator: Iterator_, context?: any): U[]; +>collect : { (list: T[], iterator: Iterator_, context?: any): U[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -4530,94 +4530,94 @@ module Underscore { >context : any >U : U - find(list: T[], iterator: Iterator, context?: any): T; ->find : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } + find(list: T[], iterator: Iterator_, context?: any): T; +>find : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - find(list: Dictionary, iterator: Iterator, context?: any): T; ->find : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } + find(list: Dictionary, iterator: Iterator_, context?: any): T; +>find : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - detect(list: T[], iterator: Iterator, context?: any): T; ->detect : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } + detect(list: T[], iterator: Iterator_, context?: any): T; +>detect : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - detect(list: Dictionary, iterator: Iterator, context?: any): T; ->detect : { (list: T[], iterator: Iterator, context?: any): T; (list: Dictionary, iterator: Iterator, context?: any): T; } + detect(list: Dictionary, iterator: Iterator_, context?: any): T; +>detect : { (list: T[], iterator: Iterator_, context?: any): T; (list: Dictionary, iterator: Iterator_, context?: any): T; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - filter(list: T[], iterator: Iterator, context?: any): T[]; ->filter : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + filter(list: T[], iterator: Iterator_, context?: any): T[]; +>filter : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - filter(list: Dictionary, iterator: Iterator, context?: any): T[]; ->filter : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + filter(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>filter : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - select(list: T[], iterator: Iterator, context?: any): T[]; ->select : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + select(list: T[], iterator: Iterator_, context?: any): T[]; +>select : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - select(list: Dictionary, iterator: Iterator, context?: any): T[]; ->select : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + select(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>select : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T @@ -4660,110 +4660,110 @@ module Underscore { >Object : Object >T : T - reject(list: T[], iterator: Iterator, context?: any): T[]; ->reject : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + reject(list: T[], iterator: Iterator_, context?: any): T[]; +>reject : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - reject(list: Dictionary, iterator: Iterator, context?: any): T[]; ->reject : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; } + reject(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>reject : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - every(list: T[], iterator?: Iterator, context?: any): boolean; ->every : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + every(list: T[], iterator?: Iterator_, context?: any): boolean; +>every : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - every(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->every : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + every(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>every : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - all(list: T[], iterator?: Iterator, context?: any): boolean; ->all : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + all(list: T[], iterator?: Iterator_, context?: any): boolean; +>all : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - all(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->all : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + all(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>all : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - some(list: T[], iterator?: Iterator, context?: any): boolean; ->some : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + some(list: T[], iterator?: Iterator_, context?: any): boolean; +>some : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - some(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->some : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + some(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>some : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - any(list: T[], iterator?: Iterator, context?: any): boolean; ->any : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + any(list: T[], iterator?: Iterator_, context?: any): boolean; +>any : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any - any(list: Dictionary, iterator?: Iterator, context?: any): boolean; ->any : { (list: T[], iterator?: Iterator, context?: any): boolean; (list: Dictionary, iterator?: Iterator, context?: any): boolean; } + any(list: Dictionary, iterator?: Iterator_, context?: any): boolean; +>any : { (list: T[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any @@ -4825,77 +4825,77 @@ module Underscore { >Dictionary : Dictionary >propertyName : string - max(list: T[], iterator?: Iterator, context?: any): T; ->max : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } + max(list: T[], iterator?: Iterator_, context?: any): T; +>max : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - max(list: Dictionary, iterator?: Iterator, context?: any): T; ->max : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } + max(list: Dictionary, iterator?: Iterator_, context?: any): T; +>max : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - min(list: T[], iterator?: Iterator, context?: any): T; ->min : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } + min(list: T[], iterator?: Iterator_, context?: any): T; +>min : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - min(list: Dictionary, iterator?: Iterator, context?: any): T; ->min : { (list: T[], iterator?: Iterator, context?: any): T; (list: Dictionary, iterator?: Iterator, context?: any): T; } + min(list: Dictionary, iterator?: Iterator_, context?: any): T; +>min : { (list: T[], iterator?: Iterator_, context?: any): T; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - sortBy(list: T[], iterator: Iterator, context?: any): T[]; ->sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } + sortBy(list: T[], iterator: Iterator_, context?: any): T[]; +>sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T - sortBy(list: Dictionary, iterator: Iterator, context?: any): T[]; ->sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } + sortBy(list: Dictionary, iterator: Iterator_, context?: any): T[]; +>sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >T : T sortBy(list: T[], propertyName: string): T[]; ->sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } +>sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >T : T >list : T[] >T : T @@ -4903,7 +4903,7 @@ module Underscore { >T : T sortBy(list: Dictionary, propertyName: string): T[]; ->sortBy : { (list: T[], iterator: Iterator, context?: any): T[]; (list: Dictionary, iterator: Iterator, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } +>sortBy : { (list: T[], iterator: Iterator_, context?: any): T[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T[]; } >T : T >list : Dictionary >Dictionary : Dictionary @@ -4911,33 +4911,33 @@ module Underscore { >propertyName : string >T : T - groupBy(list: T[], iterator?: Iterator, context?: any): Dictionary; ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } + groupBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary >T : T - groupBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } + groupBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary >T : T groupBy(list: T[], propertyName: string): Dictionary; ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : T[] >T : T @@ -4946,7 +4946,7 @@ module Underscore { >T : T groupBy(list: Dictionary, propertyName: string): Dictionary; ->groupBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : Dictionary >Dictionary : Dictionary @@ -4955,31 +4955,31 @@ module Underscore { >Dictionary : Dictionary >T : T - countBy(list: T[], iterator?: Iterator, context?: any): Dictionary; ->countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } + countBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; +>countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : T[] >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary - countBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; ->countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } + countBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; +>countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : Dictionary >Dictionary : Dictionary >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any >Dictionary : Dictionary countBy(list: T[], propertyName: string): Dictionary; ->countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : T[] >T : T @@ -4987,7 +4987,7 @@ module Underscore { >Dictionary : Dictionary countBy(list: Dictionary, propertyName: string): Dictionary; ->countBy : { (list: T[], iterator?: Iterator, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >T : T >list : Dictionary >Dictionary : Dictionary @@ -5175,44 +5175,44 @@ module Underscore { >T : T uniq(list: T[], isSorted?: boolean): T[]; ->uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >T : T >list : T[] >T : T >isSorted : boolean >T : T - uniq(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; ->uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } + uniq(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>uniq : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : T[] >T : T >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any >U : U unique(list: T[], isSorted?: boolean): T[]; ->unique : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } +>unique : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >T : T >list : T[] >T : T >isSorted : boolean >T : T - unique(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; ->unique : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; } + unique(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; +>unique : { (list: T[], isSorted?: boolean): T[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >T : T >U : U >list : T[] >T : T >isSorted : boolean ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >U : U >context : any @@ -5298,7 +5298,7 @@ module Underscore { >fromIndex : number sortedIndex(list: T[], obj: T, propertyName: string): number; ->sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator, context?: any): number; } +>sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } >T : T >list : T[] >T : T @@ -5306,15 +5306,15 @@ module Underscore { >T : T >propertyName : string - sortedIndex(list: T[], obj: T, iterator?: Iterator, context?: any): number; ->sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator, context?: any): number; } + sortedIndex(list: T[], obj: T, iterator?: Iterator_, context?: any): number; +>sortedIndex : { (list: T[], obj: T, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } >T : T >list : T[] >T : T >obj : T >T : T ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >T : T >context : any @@ -5594,12 +5594,12 @@ module Underscore { >T : T >T : T - times(n: number, iterator: Iterator, context?: any): U[]; ->times : (n: number, iterator: Iterator, context?: any) => U[] + times(n: number, iterator: Iterator_, context?: any): U[]; +>times : (n: number, iterator: Iterator_, context?: any) => U[] >U : U >n : number ->iterator : Iterator ->Iterator : Iterator +>iterator : Iterator_ +>Iterator_ : Iterator_ >U : U >context : any >U : U diff --git a/tests/baselines/reference/yieldExpression1.errors.txt b/tests/baselines/reference/yieldExpression1.errors.txt deleted file mode 100644 index 2ab6f60fb76c9..0000000000000 --- a/tests/baselines/reference/yieldExpression1.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/compiler/yieldExpression1.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - - -==== tests/cases/compiler/yieldExpression1.ts (1 errors) ==== - function* foo() { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher. - yield - } \ No newline at end of file diff --git a/tests/baselines/reference/yieldExpression1.symbols b/tests/baselines/reference/yieldExpression1.symbols new file mode 100644 index 0000000000000..7ca4678804740 --- /dev/null +++ b/tests/baselines/reference/yieldExpression1.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/yieldExpression1.ts === +function* foo() { +>foo : Symbol(foo, Decl(yieldExpression1.ts, 0, 0)) + + yield +} diff --git a/tests/baselines/reference/yieldExpression1.types b/tests/baselines/reference/yieldExpression1.types new file mode 100644 index 0000000000000..1ef54eb5f3d27 --- /dev/null +++ b/tests/baselines/reference/yieldExpression1.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/yieldExpression1.ts === +function* foo() { +>foo : () => IterableIterator + + yield +>yield : any +} diff --git a/tests/cases/compiler/underscoreTest1.ts b/tests/cases/compiler/underscoreTest1.ts index 411bcc58d5f84..dfe10cf02e288 100644 --- a/tests/cases/compiler/underscoreTest1.ts +++ b/tests/cases/compiler/underscoreTest1.ts @@ -3,7 +3,7 @@ interface Dictionary { [x: string]: T; } -interface Iterator { +interface Iterator_ { (value: T, index: any, list: any): U; } @@ -79,10 +79,10 @@ module Underscore { } export interface WrappedArray extends WrappedObject> { - each(iterator: Iterator, context?: any): void; - forEach(iterator: Iterator, context?: any): void; - map(iterator: Iterator, context?: any): U[]; - collect(iterator: Iterator, context?: any): U[]; + each(iterator: Iterator_, context?: any): void; + forEach(iterator: Iterator_, context?: any): void; + map(iterator: Iterator_, context?: any): U[]; + collect(iterator: Iterator_, context?: any): U[]; reduce(iterator: Reducer, initialValue?: T, context?: any): T; reduce(iterator: Reducer, initialValue: U, context?: any): U; foldl(iterator: Reducer, initialValue?: T, context?: any): T; @@ -93,28 +93,28 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): U; foldr(iterator: Reducer, initialValue?: T, context?: any): T; foldr(iterator: Reducer, initialValue: U, context?: any): U; - find(iterator: Iterator, context?: any): T; - detect(iterator: Iterator, context?: any): T; - filter(iterator: Iterator, context?: any): T[]; - select(iterator: Iterator, context?: any): T[]; + find(iterator: Iterator_, context?: any): T; + detect(iterator: Iterator_, context?: any): T; + filter(iterator: Iterator_, context?: any): T[]; + select(iterator: Iterator_, context?: any): T[]; where(properties: Object): T[]; findWhere(properties: Object): T; - reject(iterator: Iterator, context?: any): T[]; - every(iterator?: Iterator, context?: any): boolean; - all(iterator?: Iterator, context?: any): boolean; - some(iterator?: Iterator, context?: any): boolean; - any(iterator?: Iterator, context?: any): boolean; + reject(iterator: Iterator_, context?: any): T[]; + every(iterator?: Iterator_, context?: any): boolean; + all(iterator?: Iterator_, context?: any): boolean; + some(iterator?: Iterator_, context?: any): boolean; + any(iterator?: Iterator_, context?: any): boolean; contains(value: T): boolean; include(value: T): boolean; invoke(methodName: string, ...args: any[]): any[]; pluck(propertyName: string): any[]; - max(iterator?: Iterator, context?: any): T; - min(iterator?: Iterator, context?: any): T; - sortBy(iterator: Iterator, context?: any): T[]; + max(iterator?: Iterator_, context?: any): T; + min(iterator?: Iterator_, context?: any): T; + sortBy(iterator: Iterator_, context?: any): T[]; sortBy(propertyName: string): T[]; - groupBy(iterator?: Iterator, context?: any): Dictionary; + groupBy(iterator?: Iterator_, context?: any): Dictionary; groupBy(propertyName: string): Dictionary; - countBy(iterator?: Iterator, context?: any): Dictionary; + countBy(iterator?: Iterator_, context?: any): Dictionary; countBy(propertyName: string): Dictionary; shuffle(): T[]; toArray(): T[]; @@ -137,16 +137,16 @@ module Underscore { intersection(...arrays: T[][]): T[]; difference(...others: T[][]): T[]; uniq(isSorted?: boolean): T[]; - uniq(isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): U[]; unique(isSorted?: boolean): T[]; - unique(isSorted: boolean, iterator: Iterator, context?: any): U[]; + unique(isSorted: boolean, iterator: Iterator_, context?: any): U[]; zip(...arrays: any[][]): any[][]; object(): any; object(values: any[]): any; indexOf(value: T, isSorted?: boolean): number; lastIndexOf(value: T, fromIndex?: number): number; sortedIndex(obj: T, propertyName: string): number; - sortedIndex(obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): number; // Methods from Array concat(...items: T[]): T[]; join(separator?: string): string; @@ -162,10 +162,10 @@ module Underscore { } export interface WrappedDictionary extends WrappedObject> { - each(iterator: Iterator, context?: any): void; - forEach(iterator: Iterator, context?: any): void; - map(iterator: Iterator, context?: any): U[]; - collect(iterator: Iterator, context?: any): U[]; + each(iterator: Iterator_, context?: any): void; + forEach(iterator: Iterator_, context?: any): void; + map(iterator: Iterator_, context?: any): U[]; + collect(iterator: Iterator_, context?: any): U[]; reduce(iterator: Reducer, initialValue?: T, context?: any): T; reduce(iterator: Reducer, initialValue: U, context?: any): U; foldl(iterator: Reducer, initialValue?: T, context?: any): T; @@ -176,28 +176,28 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): U; foldr(iterator: Reducer, initialValue?: T, context?: any): T; foldr(iterator: Reducer, initialValue: U, context?: any): U; - find(iterator: Iterator, context?: any): T; - detect(iterator: Iterator, context?: any): T; - filter(iterator: Iterator, context?: any): T[]; - select(iterator: Iterator, context?: any): T[]; + find(iterator: Iterator_, context?: any): T; + detect(iterator: Iterator_, context?: any): T; + filter(iterator: Iterator_, context?: any): T[]; + select(iterator: Iterator_, context?: any): T[]; where(properties: Object): T[]; findWhere(properties: Object): T; - reject(iterator: Iterator, context?: any): T[]; - every(iterator?: Iterator, context?: any): boolean; - all(iterator?: Iterator, context?: any): boolean; - some(iterator?: Iterator, context?: any): boolean; - any(iterator?: Iterator, context?: any): boolean; + reject(iterator: Iterator_, context?: any): T[]; + every(iterator?: Iterator_, context?: any): boolean; + all(iterator?: Iterator_, context?: any): boolean; + some(iterator?: Iterator_, context?: any): boolean; + any(iterator?: Iterator_, context?: any): boolean; contains(value: T): boolean; include(value: T): boolean; invoke(methodName: string, ...args: any[]): any[]; pluck(propertyName: string): any[]; - max(iterator?: Iterator, context?: any): T; - min(iterator?: Iterator, context?: any): T; - sortBy(iterator: Iterator, context?: any): T[]; + max(iterator?: Iterator_, context?: any): T; + min(iterator?: Iterator_, context?: any): T; + sortBy(iterator: Iterator_, context?: any): T[]; sortBy(propertyName: string): T[]; - groupBy(iterator?: Iterator, context?: any): Dictionary; + groupBy(iterator?: Iterator_, context?: any): Dictionary; groupBy(propertyName: string): Dictionary; - countBy(iterator?: Iterator, context?: any): Dictionary; + countBy(iterator?: Iterator_, context?: any): Dictionary; countBy(propertyName: string): Dictionary; shuffle(): T[]; toArray(): T[]; @@ -238,10 +238,10 @@ module Underscore { } export interface ChainedArray extends ChainedObject> { - each(iterator: Iterator, context?: any): ChainedObject; - forEach(iterator: Iterator, context?: any): ChainedObject; - map(iterator: Iterator, context?: any): ChainedArray; - collect(iterator: Iterator, context?: any): ChainedArray; + each(iterator: Iterator_, context?: any): ChainedObject; + forEach(iterator: Iterator_, context?: any): ChainedObject; + map(iterator: Iterator_, context?: any): ChainedArray; + collect(iterator: Iterator_, context?: any): ChainedArray; reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldl(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; @@ -252,29 +252,29 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue: U, context?: any): ChainedObject; - find(iterator: Iterator, context?: any): ChainedObject; - detect(iterator: Iterator, context?: any): ChainedObject; - filter(iterator: Iterator, context?: any): ChainedArray; - select(iterator: Iterator, context?: any): ChainedArray; + find(iterator: Iterator_, context?: any): ChainedObject; + detect(iterator: Iterator_, context?: any): ChainedObject; + filter(iterator: Iterator_, context?: any): ChainedArray; + select(iterator: Iterator_, context?: any): ChainedArray; where(properties: Object): ChainedArray; findWhere(properties: Object): ChainedObject; - reject(iterator: Iterator, context?: any): ChainedArray; - every(iterator?: Iterator, context?: any): ChainedObject; - all(iterator?: Iterator, context?: any): ChainedObject; - some(iterator?: Iterator, context?: any): ChainedObject; - any(iterator?: Iterator, context?: any): ChainedObject; + reject(iterator: Iterator_, context?: any): ChainedArray; + every(iterator?: Iterator_, context?: any): ChainedObject; + all(iterator?: Iterator_, context?: any): ChainedObject; + some(iterator?: Iterator_, context?: any): ChainedObject; + any(iterator?: Iterator_, context?: any): ChainedObject; contains(value: T): ChainedObject; include(value: T): ChainedObject; invoke(methodName: string, ...args: any[]): ChainedArray; pluck(propertyName: string): ChainedArray; - max(iterator?: Iterator, context?: any): ChainedObject; - min(iterator?: Iterator, context?: any): ChainedObject; - sortBy(iterator: Iterator, context?: any): ChainedArray; + max(iterator?: Iterator_, context?: any): ChainedObject; + min(iterator?: Iterator_, context?: any): ChainedObject; + sortBy(iterator: Iterator_, context?: any): ChainedArray; sortBy(propertyName: string): ChainedArray; // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; groupBy(propertyName: string): ChainedDictionary; - countBy(iterator?: Iterator, context?: any): ChainedDictionary; + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; countBy(propertyName: string): ChainedDictionary; shuffle(): ChainedArray; toArray(): ChainedArray; @@ -297,16 +297,16 @@ module Underscore { intersection(...arrays: T[][]): ChainedArray; difference(...others: T[][]): ChainedArray; uniq(isSorted?: boolean): ChainedArray; - uniq(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; + uniq(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; unique(isSorted?: boolean): ChainedArray; - unique(isSorted: boolean, iterator: Iterator, context?: any): ChainedArray; + unique(isSorted: boolean, iterator: Iterator_, context?: any): ChainedArray; zip(...arrays: any[][]): ChainedArray; object(): ChainedObject; object(values: any[]): ChainedObject; indexOf(value: T, isSorted?: boolean): ChainedObject; lastIndexOf(value: T, fromIndex?: number): ChainedObject; sortedIndex(obj: T, propertyName: string): ChainedObject; - sortedIndex(obj: T, iterator?: Iterator, context?: any): ChainedObject; + sortedIndex(obj: T, iterator?: Iterator_, context?: any): ChainedObject; // Methods from Array concat(...items: T[]): ChainedArray; join(separator?: string): ChainedObject; @@ -329,10 +329,10 @@ module Underscore { } export interface ChainedDictionary extends ChainedObject> { - each(iterator: Iterator, context?: any): ChainedObject; - forEach(iterator: Iterator, context?: any): ChainedObject; - map(iterator: Iterator, context?: any): ChainedArray; - collect(iterator: Iterator, context?: any): ChainedArray; + each(iterator: Iterator_, context?: any): ChainedObject; + forEach(iterator: Iterator_, context?: any): ChainedObject; + map(iterator: Iterator_, context?: any): ChainedArray; + collect(iterator: Iterator_, context?: any): ChainedArray; reduce(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; reduce(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldl(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; @@ -343,29 +343,29 @@ module Underscore { reduceRight(iterator: Reducer, initialValue: U, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue?: T, context?: any): ChainedObject; foldr(iterator: Reducer, initialValue: U, context?: any): ChainedObject; - find(iterator: Iterator, context?: any): ChainedObject; - detect(iterator: Iterator, context?: any): ChainedObject; - filter(iterator: Iterator, context?: any): ChainedArray; - select(iterator: Iterator, context?: any): ChainedArray; + find(iterator: Iterator_, context?: any): ChainedObject; + detect(iterator: Iterator_, context?: any): ChainedObject; + filter(iterator: Iterator_, context?: any): ChainedArray; + select(iterator: Iterator_, context?: any): ChainedArray; where(properties: Object): ChainedArray; findWhere(properties: Object): ChainedObject; - reject(iterator: Iterator, context?: any): ChainedArray; - every(iterator?: Iterator, context?: any): ChainedObject; - all(iterator?: Iterator, context?: any): ChainedObject; - some(iterator?: Iterator, context?: any): ChainedObject; - any(iterator?: Iterator, context?: any): ChainedObject; + reject(iterator: Iterator_, context?: any): ChainedArray; + every(iterator?: Iterator_, context?: any): ChainedObject; + all(iterator?: Iterator_, context?: any): ChainedObject; + some(iterator?: Iterator_, context?: any): ChainedObject; + any(iterator?: Iterator_, context?: any): ChainedObject; contains(value: T): ChainedObject; include(value: T): ChainedObject; invoke(methodName: string, ...args: any[]): ChainedArray; pluck(propertyName: string): ChainedArray; - max(iterator?: Iterator, context?: any): ChainedObject; - min(iterator?: Iterator, context?: any): ChainedObject; - sortBy(iterator: Iterator, context?: any): ChainedArray; + max(iterator?: Iterator_, context?: any): ChainedObject; + min(iterator?: Iterator_, context?: any): ChainedObject; + sortBy(iterator: Iterator_, context?: any): ChainedArray; sortBy(propertyName: string): ChainedArray; // Should return ChainedDictionary, but expansive recursion not allowed - groupBy(iterator?: Iterator, context?: any): ChainedDictionary; + groupBy(iterator?: Iterator_, context?: any): ChainedDictionary; groupBy(propertyName: string): ChainedDictionary; - countBy(iterator?: Iterator, context?: any): ChainedDictionary; + countBy(iterator?: Iterator_, context?: any): ChainedDictionary; countBy(propertyName: string): ChainedDictionary; shuffle(): ChainedArray; toArray(): ChainedArray; @@ -396,15 +396,15 @@ module Underscore { chain(list: Dictionary): ChainedDictionary; chain(obj: T): ChainedObject; - each(list: T[], iterator: Iterator, context?: any): void; - each(list: Dictionary, iterator: Iterator, context?: any): void; - forEach(list: T[], iterator: Iterator, context?: any): void; - forEach(list: Dictionary, iterator: Iterator, context?: any): void; + each(list: T[], iterator: Iterator_, context?: any): void; + each(list: Dictionary, iterator: Iterator_, context?: any): void; + forEach(list: T[], iterator: Iterator_, context?: any): void; + forEach(list: Dictionary, iterator: Iterator_, context?: any): void; - map(list: T[], iterator: Iterator, context?: any): U[]; - map(list: Dictionary, iterator: Iterator, context?: any): U[]; - collect(list: T[], iterator: Iterator, context?: any): U[]; - collect(list: Dictionary, iterator: Iterator, context?: any): U[]; + map(list: T[], iterator: Iterator_, context?: any): U[]; + map(list: Dictionary, iterator: Iterator_, context?: any): U[]; + collect(list: T[], iterator: Iterator_, context?: any): U[]; + collect(list: Dictionary, iterator: Iterator_, context?: any): U[]; reduce(list: T[], iterator: Reducer, initialValue?: T, context?: any): T; reduce(list: T[], iterator: Reducer, initialValue: U, context?: any): U; @@ -428,15 +428,15 @@ module Underscore { foldr(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; foldr(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; - find(list: T[], iterator: Iterator, context?: any): T; - find(list: Dictionary, iterator: Iterator, context?: any): T; - detect(list: T[], iterator: Iterator, context?: any): T; - detect(list: Dictionary, iterator: Iterator, context?: any): T; + find(list: T[], iterator: Iterator_, context?: any): T; + find(list: Dictionary, iterator: Iterator_, context?: any): T; + detect(list: T[], iterator: Iterator_, context?: any): T; + detect(list: Dictionary, iterator: Iterator_, context?: any): T; - filter(list: T[], iterator: Iterator, context?: any): T[]; - filter(list: Dictionary, iterator: Iterator, context?: any): T[]; - select(list: T[], iterator: Iterator, context?: any): T[]; - select(list: Dictionary, iterator: Iterator, context?: any): T[]; + filter(list: T[], iterator: Iterator_, context?: any): T[]; + filter(list: Dictionary, iterator: Iterator_, context?: any): T[]; + select(list: T[], iterator: Iterator_, context?: any): T[]; + select(list: Dictionary, iterator: Iterator_, context?: any): T[]; where(list: T[], properties: Object): T[]; where(list: Dictionary, properties: Object): T[]; @@ -444,18 +444,18 @@ module Underscore { findWhere(list: T[], properties: Object): T; findWhere(list: Dictionary, properties: Object): T; - reject(list: T[], iterator: Iterator, context?: any): T[]; - reject(list: Dictionary, iterator: Iterator, context?: any): T[]; + reject(list: T[], iterator: Iterator_, context?: any): T[]; + reject(list: Dictionary, iterator: Iterator_, context?: any): T[]; - every(list: T[], iterator?: Iterator, context?: any): boolean; - every(list: Dictionary, iterator?: Iterator, context?: any): boolean; - all(list: T[], iterator?: Iterator, context?: any): boolean; - all(list: Dictionary, iterator?: Iterator, context?: any): boolean; + every(list: T[], iterator?: Iterator_, context?: any): boolean; + every(list: Dictionary, iterator?: Iterator_, context?: any): boolean; + all(list: T[], iterator?: Iterator_, context?: any): boolean; + all(list: Dictionary, iterator?: Iterator_, context?: any): boolean; - some(list: T[], iterator?: Iterator, context?: any): boolean; - some(list: Dictionary, iterator?: Iterator, context?: any): boolean; - any(list: T[], iterator?: Iterator, context?: any): boolean; - any(list: Dictionary, iterator?: Iterator, context?: any): boolean; + some(list: T[], iterator?: Iterator_, context?: any): boolean; + some(list: Dictionary, iterator?: Iterator_, context?: any): boolean; + any(list: T[], iterator?: Iterator_, context?: any): boolean; + any(list: Dictionary, iterator?: Iterator_, context?: any): boolean; contains(list: T[], value: T): boolean; contains(list: Dictionary, value: T): boolean; @@ -468,24 +468,24 @@ module Underscore { pluck(list: any[], propertyName: string): any[]; pluck(list: Dictionary, propertyName: string): any[]; - max(list: T[], iterator?: Iterator, context?: any): T; - max(list: Dictionary, iterator?: Iterator, context?: any): T; + max(list: T[], iterator?: Iterator_, context?: any): T; + max(list: Dictionary, iterator?: Iterator_, context?: any): T; - min(list: T[], iterator?: Iterator, context?: any): T; - min(list: Dictionary, iterator?: Iterator, context?: any): T; + min(list: T[], iterator?: Iterator_, context?: any): T; + min(list: Dictionary, iterator?: Iterator_, context?: any): T; - sortBy(list: T[], iterator: Iterator, context?: any): T[]; - sortBy(list: Dictionary, iterator: Iterator, context?: any): T[]; + sortBy(list: T[], iterator: Iterator_, context?: any): T[]; + sortBy(list: Dictionary, iterator: Iterator_, context?: any): T[]; sortBy(list: T[], propertyName: string): T[]; sortBy(list: Dictionary, propertyName: string): T[]; - groupBy(list: T[], iterator?: Iterator, context?: any): Dictionary; - groupBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; + groupBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; + groupBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; groupBy(list: T[], propertyName: string): Dictionary; groupBy(list: Dictionary, propertyName: string): Dictionary; - countBy(list: T[], iterator?: Iterator, context?: any): Dictionary; - countBy(list: Dictionary, iterator?: Iterator, context?: any): Dictionary; + countBy(list: T[], iterator?: Iterator_, context?: any): Dictionary; + countBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; countBy(list: T[], propertyName: string): Dictionary; countBy(list: Dictionary, propertyName: string): Dictionary; @@ -527,9 +527,9 @@ module Underscore { difference(list: T[], ...others: T[][]): T[]; uniq(list: T[], isSorted?: boolean): T[]; - uniq(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; + uniq(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; unique(list: T[], isSorted?: boolean): T[]; - unique(list: T[], isSorted: boolean, iterator: Iterator, context?: any): U[]; + unique(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; zip(a0: T0[], a1: T1[]): Tuple2[]; zip(a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; @@ -544,7 +544,7 @@ module Underscore { lastIndexOf(list: T[], value: T, fromIndex?: number): number; sortedIndex(list: T[], obj: T, propertyName: string): number; - sortedIndex(list: T[], obj: T, iterator?: Iterator, context?: any): number; + sortedIndex(list: T[], obj: T, iterator?: Iterator_, context?: any): number; range(stop: number): number[]; range(start: number, stop: number, step?: number): number[]; @@ -621,7 +621,7 @@ module Underscore { identity(value: T): T; - times(n: number, iterator: Iterator, context?: any): U[]; + times(n: number, iterator: Iterator_, context?: any): U[]; random(max: number): number; random(min: number, max: number): number; @@ -647,255 +647,255 @@ module Underscore { declare var _: Underscore.Static; // @Filename: underscoreTest1_underscoreTests.ts -/// - -declare var $; -declare function alert(x: string): void; - -_.each([1, 2, 3], (num) => alert(num.toString())); -_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())); - -_.map([1, 2, 3], (num) => num * 3); -_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3); - -var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0); - -var list = [[0, 1], [2, 3], [4, 5]]; -var flat = _.reduceRight(list, (a, b) => a.concat(b), []); - -var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); - -var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); - -var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }]; -_.where(listOfPlays, { author: "Shakespeare", year: 1611 }); - -var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); - -_.all([true, 1, null, 'yes'], _.identity); - -_.any([null, 0, 'yes', false]); - -_.contains([1, 2, 3], 3); - -_.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); - -var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }]; -_.pluck(stooges, 'name'); - -_.max(stooges, (stooge) => stooge.age); - -var numbers = [10, 5, 100, 2, 1000]; -_.min(numbers); - -_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); - - -// not sure how this is typechecking at all.. Math.floor(e) is number not string..? -_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)); -_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); -_.groupBy(['one', 'two', 'three'], 'length'); - -_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd'); - -_.shuffle([1, 2, 3, 4, 5, 6]); - -// (function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4); - -_.size({ one: 1, two: 2, three: 3 }); - -/////////////////////////////////////////////////////////////////////////////////////// - -_.first([5, 4, 3, 2, 1]); -_.initial([5, 4, 3, 2, 1]); -_.last([5, 4, 3, 2, 1]); -_.rest([5, 4, 3, 2, 1]); -_.compact([0, 1, false, 2, '', 3]); - -_.flatten([1, 2, 3, 4]); -_.flatten([1, [2]]); - -// typescript doesn't like the elements being different -_.flatten([1, [2], [3, [[4]]]]); -_.flatten([1, [2], [3, [[4]]]], true); -_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); -_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]); -_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); -_.difference([1, 2, 3, 4, 5], [5, 2, 10]); -_.uniq([1, 2, 1, 3, 1, 4]); -_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); -_.object(['moe', 'larry', 'curly'], [30, 40, 50]); -_.object([['moe', 30], ['larry', 40], ['curly', 50]]); -_.indexOf([1, 2, 3], 2); -_.lastIndexOf([1, 2, 3, 1, 2, 3], 2); -_.sortedIndex([10, 20, 30, 40, 50], 35); -_.range(10); -_.range(1, 11); -_.range(0, 30, 5); -_.range(0, 30, 5); -_.range(0); - -/////////////////////////////////////////////////////////////////////////////////////// - -var func = function (greeting) { return greeting + ': ' + this.name }; -// need a second var otherwise typescript thinks func signature is the above func type, -// instead of the newly returned _bind => func type. -var func2 = _.bind(func, { name: 'moe' }, 'hi'); -func2(); - -var buttonView = { - label: 'underscore', - onClick: function () { alert('clicked: ' + this.label); }, - onHover: function () { alert('hovering: ' + this.label); } -}; -_.bindAll(buttonView); -$('#underscore_button').bind('click', buttonView.onClick); - -var fibonacci = _.memoize(function (n) { - return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); -}); - -var log = _.bind((message?: string, ...rest: string[]) => { }, Date); -_.delay(log, 1000, 'logged later'); - -_.defer(function () { alert('deferred'); }); - -var updatePosition = () => alert('updating position...'); -var throttled = _.throttle(updatePosition, 100); -$(null).scroll(throttled); - -var calculateLayout = () => alert('calculating layout...'); -var lazyLayout = _.debounce(calculateLayout, 300); -$(null).resize(lazyLayout); - -var createApplication = () => alert('creating application...'); -var initialize = _.once(createApplication); -initialize(); -initialize(); - -var notes: any[]; -var render = () => alert("rendering..."); -var renderNotes = _.after(notes.length, render); -_.each(notes, (note) => note.asyncSave({ success: renderNotes })); - -var hello = function (name) { return "hello: " + name; }; -hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; }); -hello("moe"); - -var greet = function (name) { return "hi: " + name; }; -var exclaim = function (statement) { return statement + "!"; }; -var welcome = _.compose(exclaim, greet); -welcome('moe'); - -/////////////////////////////////////////////////////////////////////////////////////// - -_.keys({ one: 1, two: 2, three: 3 }); -_.values({ one: 1, two: 2, three: 3 }); -_.pairs({ one: 1, two: 2, three: 3 }); -_.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" }); -_.functions(_); -_.extend({ name: 'moe' }, { age: 50 }); -_.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age'); -_.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid'); - -var iceCream = { flavor: "chocolate" }; -_.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" }); - -_.clone({ name: 'moe' }); - -_.chain([1, 2, 3, 200]) - .filter(function (num) { return num % 2 == 0; }) - .tap(alert) - .map(function (num) { return num * num }) - .value(); - -_.has({ a: 1, b: 2, c: 3 }, "b"); - -var moe = { name: 'moe', luckyNumbers: [13, 27, 34] }; -var clone = { name: 'moe', luckyNumbers: [13, 27, 34] }; -moe == clone; -_.isEqual(moe, clone); - -_.isEmpty([1, 2, 3]); -_.isEmpty({}); - -_.isElement($('body')[0]); - -(function () { return _.isArray(arguments); })(); -_.isArray([1, 2, 3]); - -_.isObject({}); -_.isObject(1); - - -// (() => { return _.isArguments(arguments); })(1, 2, 3); -_.isArguments([1, 2, 3]); - -_.isFunction(alert); - -_.isString("moe"); - -_.isNumber(8.4 * 5); - -_.isFinite(-101); - -_.isFinite(-Infinity); - -_.isBoolean(null); - -_.isDate(new Date()); - -_.isRegExp(/moe/); - -_.isNaN(NaN); -isNaN(undefined); -_.isNaN(undefined); - -_.isNull(null); -_.isNull(undefined); - -_.isUndefined((null).missingVariable); - -/////////////////////////////////////////////////////////////////////////////////////// - -var underscore = _.noConflict(); - -var moe2 = { name: 'moe' }; -moe2 === _.identity(moe); - -var genie; - -_.times(3, function (n) { genie.grantWishNumber(n); }); - -_.random(0, 100); - -_.mixin({ - capitalize: function (string) { - return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase(); - } -}); -(_("fabio")).capitalize(); - -_.uniqueId('contact_'); - -_.escape('Curly, Larry & Moe'); - -var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } }; -_.result(object, 'cheese'); - -_.result(object, 'stuff'); - -var compiled = _.template("hello: <%= name %>"); -compiled({ name: 'moe' }); -var list2 = "<% _.each(people, function(name) { %>
  • <%= name %>
    • <% }); %>"; -_.template(list2, { people: ['moe', 'curly', 'larry'] }); -var template = _.template("<%- value %>"); -template({ value: '