From 3f7b53e0cd80bb529d280c6b0fcfe283d922d196 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Tue, 18 Apr 2017 14:10:58 -0700 Subject: [PATCH 01/17] Use base tsconfig's compileOnSave option if tsconfig.json doesnt have it specified Fixes #13910 --- src/compiler/commandLineParser.ts | 14 +++++++++----- src/harness/unittests/compileOnSave.ts | 23 +++++++++++++++++++++++ 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 9a2f19dcc13..a5990a5a31b 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -1111,10 +1111,11 @@ namespace ts { const jsonOptions = json["typeAcquisition"] || json["typingOptions"]; const typeAcquisition: TypeAcquisition = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName); + let baseCompileOnSave: boolean; if (json["extends"]) { let [include, exclude, files, baseOptions]: [string[], string[], string[], CompilerOptions] = [undefined, undefined, undefined, {}]; if (typeof json["extends"] === "string") { - [include, exclude, files, baseOptions] = (tryExtendsName(json["extends"]) || [include, exclude, files, baseOptions]); + [include, exclude, files, baseCompileOnSave, baseOptions] = (tryExtendsName(json["extends"]) || [include, exclude, files, baseCompileOnSave, baseOptions]); } else { errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string")); @@ -1135,7 +1136,10 @@ namespace ts { options.configFilePath = configFileName; const { fileNames, wildcardDirectories } = getFileNames(errors); - const compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors); + let compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors); + if (baseCompileOnSave && json[compileOnSaveCommandLineOption.name] === undefined) { + compileOnSave = baseCompileOnSave; + } return { options, @@ -1147,7 +1151,7 @@ namespace ts { compileOnSave }; - function tryExtendsName(extendedConfig: string): [string[], string[], string[], CompilerOptions] { + function tryExtendsName(extendedConfig: string): [string[], string[], string[], boolean, CompilerOptions] { // If the path isn't a rooted or relative path, don't try to resolve it (we reserve the right to special case module-id like paths in the future) if (!(isRootedDiskPath(extendedConfig) || startsWith(normalizeSlashes(extendedConfig), "./") || startsWith(normalizeSlashes(extendedConfig), "../"))) { errors.push(createCompilerDiagnostic(Diagnostics.A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not, extendedConfig)); @@ -1177,7 +1181,7 @@ namespace ts { return map(extendedResult.config[key], updatePath); } }); - return [include, exclude, files, result.options]; + return [include, exclude, files, result.compileOnSave, result.options]; } function getFileNames(errors: Diagnostic[]): ExpandResult { @@ -1245,7 +1249,7 @@ namespace ts { } } - export function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean { + export function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean | undefined { if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) { return false; } diff --git a/src/harness/unittests/compileOnSave.ts b/src/harness/unittests/compileOnSave.ts index 506559bd3d9..eaab86b4ebc 100644 --- a/src/harness/unittests/compileOnSave.ts +++ b/src/harness/unittests/compileOnSave.ts @@ -317,6 +317,29 @@ namespace ts.projectSystem { sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, []); }); + it("should save when compileOnSave is enabled in base tsconfig.json", () => { + configFile = { + path: "/a/b/tsconfig.json", + content: `{ + "extends": "/a/tsconfig.json" + }` + }; + + const configFile2: FileOrFolder = { + path: "/a/tsconfig.json", + content: `{ + "compileOnSave": true + }` + }; + + const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, configFile2, configFile, libFile]); + const typingsInstaller = createTestTypingsInstaller(host); + const session = createSession(host, typingsInstaller); + + openFilesForSession([moduleFile1, file1Consumer1], session); + sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]); + }); + it("should always return the file itself if '--isolatedModules' is specified", () => { configFile = { path: "/a/b/tsconfig.json", From f6324e7914af0104fa7ad5117bb37a26b3ca2cd1 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 18 Apr 2017 16:18:13 -0700 Subject: [PATCH 02/17] Add tests --- .../unittests/tsserverProjectSystem.ts | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 66d9cb087b6..92e811a62e4 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -3204,6 +3204,122 @@ namespace ts.projectSystem { const errorResult = session.executeCommand(dTsFileGetErrRequest).response; assert.isTrue(errorResult.length === 0); }); + + it("should not report bind errors for declaration files with skipLibCheck=true", () => { + const jsconfigFile = { + path: "/a/jsconfig.json", + content: "{}" + }; + const jsFile = { + path: "/a/jsFile.js", + content: "let x = 1;" + }; + const dTsFile1 = { + path: "/a/dTsFile1.d.ts", + content: ` + declare var x: number;` + }; + const dTsFile2 = { + path: "/a/dTsFile2.d.ts", + content: ` + declare var x: string;` + }; + const host = createServerHost([jsconfigFile, jsFile, dTsFile1, dTsFile2]); + const session = createSession(host); + openFilesForSession([jsFile], session); + + const dTsFile1GetErrRequest = makeSessionRequest( + CommandNames.SemanticDiagnosticsSync, + { file: dTsFile1.path } + ); + let error1Result = session.executeCommand(dTsFile1GetErrRequest).response; + assert.isTrue(error1Result.length === 0); + + const dTsFile2GetErrRequest = makeSessionRequest( + CommandNames.SemanticDiagnosticsSync, + { file: dTsFile2.path } + ); + let error2Result = session.executeCommand(dTsFile2GetErrRequest).response; + assert.isTrue(error2Result.length === 0); + }); + + it("should report semanitc errors for loose JS files with '// @ts-check' and skipLibCheck=true", () => { + const jsFile = { + path: "/a/jsFile.js", + content: ` + // @ts-check + let x = 1; + x === "string";` + }; + + const host = createServerHost([jsFile]); + const session = createSession(host); + openFilesForSession([jsFile], session); + + const getErrRequest = makeSessionRequest( + CommandNames.SemanticDiagnosticsSync, + { file: jsFile.path } + ); + const errorResult = session.executeCommand(getErrRequest).response; + assert.isTrue(errorResult.length === 1); + assert.equal(errorResult[0].code, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code); + }); + + it("should report semanitc errors for configured js project with '// @ts-check' and skipLibCheck=true", () => { + const jsconfigFile = { + path: "/a/jsconfig.json", + content: "{}" + }; + + const jsFile = { + path: "/a/jsFile.js", + content: ` + // @ts-check + let x = 1; + x === "string";` + }; + + const host = createServerHost([jsconfigFile, jsFile]); + const session = createSession(host); + openFilesForSession([jsFile], session); + + const getErrRequest = makeSessionRequest( + CommandNames.SemanticDiagnosticsSync, + { file: jsFile.path } + ); + const errorResult = session.executeCommand(getErrRequest).response; + assert.isTrue(errorResult.length === 1); + assert.equal(errorResult[0].code, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code); + }); + + it("should report semanitc errors for configured js project with checkJs=true and skipLibCheck=true", () => { + const jsconfigFile = { + path: "/a/jsconfig.json", + content: JSON.stringify({ + compilerOptions: { + checkJs: true, + skipLibCheck: true + }, + }) + }; + const jsFile = { + path: "/a/jsFile.js", + content: `let x = 1; + x === "string";` + }; + + const host = createServerHost([jsconfigFile, jsFile]); + const session = createSession(host); + openFilesForSession([jsFile], session); + + const getErrRequest = makeSessionRequest( + CommandNames.SemanticDiagnosticsSync, + { file: jsFile.path } + ); + const errorResult = session.executeCommand(getErrRequest).response; + assert.isTrue(errorResult.length === 1); + assert.equal(errorResult[0].code, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code); + }); }); describe("non-existing directories listed in config file input array", () => { From effa032d5dcdfbf2909fb12b4f6993385cceda90 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 18 Apr 2017 16:18:27 -0700 Subject: [PATCH 03/17] mergeSymbol error uses first decl not valueDecl Previously it assumed valueDeclaration was present, which is not true for type aliases. --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6e249c3977d..81ea34b0510 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -574,7 +574,7 @@ namespace ts { recordMergedSymbol(target, source); } else if (target.flags & SymbolFlags.NamespaceModule) { - error(source.valueDeclaration.name, Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target)); + error(source.declarations[0].name, Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target)); } else { const message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable From eba15f41e4f6696fa4a2807a77538466cda33712 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Tue, 18 Apr 2017 16:19:05 -0700 Subject: [PATCH 04/17] Test:type alias merged w/interface-namespace errors Previously it crashed when it assumed valueDeclaration was always defined. --- .../reference/noSymbolForMergeCrash.errors.txt | 12 ++++++++++++ tests/baselines/reference/noSymbolForMergeCrash.js | 12 ++++++++++++ tests/cases/compiler/noSymbolForMergeCrash.ts | 6 ++++++ 3 files changed, 30 insertions(+) create mode 100644 tests/baselines/reference/noSymbolForMergeCrash.errors.txt create mode 100644 tests/baselines/reference/noSymbolForMergeCrash.js create mode 100644 tests/cases/compiler/noSymbolForMergeCrash.ts diff --git a/tests/baselines/reference/noSymbolForMergeCrash.errors.txt b/tests/baselines/reference/noSymbolForMergeCrash.errors.txt new file mode 100644 index 00000000000..1f8cd7897e0 --- /dev/null +++ b/tests/baselines/reference/noSymbolForMergeCrash.errors.txt @@ -0,0 +1,12 @@ +tests/cases/compiler/final.ts(1,6): error TS2649: Cannot augment module 'A' with value exports because it resolves to a non-module entity. + + +==== tests/cases/compiler/initial.ts (0 errors) ==== + interface A { } + namespace A {} + +==== tests/cases/compiler/final.ts (1 errors) ==== + type A = {} + ~ +!!! error TS2649: Cannot augment module 'A' with value exports because it resolves to a non-module entity. + \ No newline at end of file diff --git a/tests/baselines/reference/noSymbolForMergeCrash.js b/tests/baselines/reference/noSymbolForMergeCrash.js new file mode 100644 index 00000000000..341c9313982 --- /dev/null +++ b/tests/baselines/reference/noSymbolForMergeCrash.js @@ -0,0 +1,12 @@ +//// [tests/cases/compiler/noSymbolForMergeCrash.ts] //// + +//// [initial.ts] +interface A { } +namespace A {} + +//// [final.ts] +type A = {} + + +//// [initial.js] +//// [final.js] diff --git a/tests/cases/compiler/noSymbolForMergeCrash.ts b/tests/cases/compiler/noSymbolForMergeCrash.ts new file mode 100644 index 00000000000..a4e5eec8a19 --- /dev/null +++ b/tests/cases/compiler/noSymbolForMergeCrash.ts @@ -0,0 +1,6 @@ +// @Filename: initial.ts +interface A { } +namespace A {} + +// @Filename: final.ts +type A = {} From 92d592c23dcbfbd1717c72ca9cdc9b7c5198c7a9 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 18 Apr 2017 16:19:28 -0700 Subject: [PATCH 05/17] Update logic for shouldSkipSemanticCheck to allow for quering semantic errors for JS files with @ts-check --- src/server/session.ts | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/server/session.ts b/src/server/session.ts index 742f8a3c228..57a3d0a5002 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -25,15 +25,17 @@ namespace ts.server { return ((1e9 * seconds) + nanoseconds) / 1000000.0; } - function shouldSkipSemanticCheck(project: Project) { - if (project.projectKind === ProjectKind.Inferred || project.projectKind === ProjectKind.External) { - return project.isJsOnlyProject(); - } - else { - // For configured projects, require that skipLibCheck be set also - const options = project.getCompilerOptions(); - return options.skipLibCheck && !options.checkJs && project.isJsOnlyProject(); + function shouldSkipSemanticCheck(project: Project, file: NormalizedPath) { + // For inferred (e.g. miscellaneous context in VS) and external projects (e.g. VS .csproj project) with only JS files + // semantic errors in .d.ts files (e.g. ones added by automatic type acquisition) are not interesting. + // We want to avoid the cost of querying for these errors all together, even if 'skipLibCheck' is not set. + // We still want to check .js files (e.g. '// @ts-check' or '--checkJs' is set). + if ((project.projectKind === ProjectKind.Inferred || project.projectKind === ProjectKind.External) && + project.isJsOnlyProject()) { + const scriptInfo = project.getScriptInfoForNormalizedPath(file); + return scriptInfo && !scriptInfo.isJavaScript(); } + return false; } interface FileStart { @@ -489,7 +491,7 @@ namespace ts.server { private semanticCheck(file: NormalizedPath, project: Project) { try { let diags: Diagnostic[] = []; - if (!shouldSkipSemanticCheck(project)) { + if (!shouldSkipSemanticCheck(project, file)) { diags = project.getLanguageService().getSemanticDiagnostics(file); } @@ -597,7 +599,7 @@ namespace ts.server { private getDiagnosticsWorker(args: protocol.FileRequestArgs, isSemantic: boolean, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) { const { project, file } = this.getFileAndProject(args); - if (isSemantic && shouldSkipSemanticCheck(project)) { + if (isSemantic && shouldSkipSemanticCheck(project, file)) { return []; } const scriptInfo = project.getScriptInfoForNormalizedPath(file); From 8c33a792b3293f838d47c87ffb46153f384483eb Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 18 Apr 2017 16:19:58 -0700 Subject: [PATCH 06/17] Do not query for bind errors if skipLibCheck or skipDefaultLibCheck is set --- src/compiler/program.ts | 7 +++++++ tests/cases/compiler/noDefaultLib.ts | 1 + tests/cases/compiler/variableDeclarationInStrictMode1.ts | 1 + 3 files changed, 9 insertions(+) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 0971adfc098..347e6e97ebd 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -908,6 +908,13 @@ namespace ts { function getSemanticDiagnosticsForFileNoCache(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] { return runWithCancellationToken(() => { + // If skipLibCheck is enabled, skip reporting errors if file is a declaration file. + // If skipDefaultLibCheck is enabled, skip reporting errors if file contains a + // '/// ' directive. + if (options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib) { + return emptyArray; + } + const typeChecker = getDiagnosticsProducingTypeChecker(); Debug.assert(!!sourceFile.bindDiagnostics); diff --git a/tests/cases/compiler/noDefaultLib.ts b/tests/cases/compiler/noDefaultLib.ts index 92c8a63fc64..fa1230e4cfe 100644 --- a/tests/cases/compiler/noDefaultLib.ts +++ b/tests/cases/compiler/noDefaultLib.ts @@ -1,3 +1,4 @@ +// @skipDefaultLibCheck: false /// var x; diff --git a/tests/cases/compiler/variableDeclarationInStrictMode1.ts b/tests/cases/compiler/variableDeclarationInStrictMode1.ts index 266e5af44ae..5785beb32aa 100644 --- a/tests/cases/compiler/variableDeclarationInStrictMode1.ts +++ b/tests/cases/compiler/variableDeclarationInStrictMode1.ts @@ -1,2 +1,3 @@ +// @skipDefaultLibCheck: false "use strict"; var eval; \ No newline at end of file From 35024b4f9020b46e553c2f3a9ff4b9bd6e3e252b Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 18 Apr 2017 16:20:29 -0700 Subject: [PATCH 07/17] Fix lint errors --- src/harness/unittests/tsserverProjectSystem.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 92e811a62e4..fc9c6ff8bb0 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -3232,14 +3232,14 @@ namespace ts.projectSystem { CommandNames.SemanticDiagnosticsSync, { file: dTsFile1.path } ); - let error1Result = session.executeCommand(dTsFile1GetErrRequest).response; + const error1Result = session.executeCommand(dTsFile1GetErrRequest).response; assert.isTrue(error1Result.length === 0); const dTsFile2GetErrRequest = makeSessionRequest( CommandNames.SemanticDiagnosticsSync, { file: dTsFile2.path } ); - let error2Result = session.executeCommand(dTsFile2GetErrRequest).response; + const error2Result = session.executeCommand(dTsFile2GetErrRequest).response; assert.isTrue(error2Result.length === 0); }); From 0e0679309805fe3806709280f7334e0b7ad79663 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Wed, 19 Apr 2017 07:07:16 -0700 Subject: [PATCH 08/17] Remove unused file --- src/services/goToImplementation.ts | 27 --------------------------- 1 file changed, 27 deletions(-) delete mode 100644 src/services/goToImplementation.ts diff --git a/src/services/goToImplementation.ts b/src/services/goToImplementation.ts deleted file mode 100644 index 1d9f48ae5e8..00000000000 --- a/src/services/goToImplementation.ts +++ /dev/null @@ -1,27 +0,0 @@ -/* @internal */ -namespace ts.GoToImplementation { - export function getImplementationAtPosition(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): ImplementationLocation[] { - const context = new FindAllReferences.FindImplementationsContext(typeChecker, cancellationToken); - // If invoked directly on a shorthand property assignment, then return - // the declaration of the symbol being assigned (not the symbol being assigned to). - if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { - const result: ImplementationLocation[] = []; - FindAllReferences.getReferenceEntriesForShorthandPropertyAssignment(node, context, result); - return result.length > 0 ? result : undefined; - } - else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) { - // References to and accesses on the super keyword only have one possible implementation, so no - // need to "Find all References" - const symbol = typeChecker.getSymbolAtLocation(node); - return symbol.valueDeclaration && [context.getReferenceEntryFromNode(symbol.valueDeclaration)]; - } - else { - // Perform "Find all References" and retrieve only those that are implementations - const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(context, - node, sourceFiles, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/ false, /*implementations*/ true); - const result = flatMap(referencedSymbols, symbol => symbol.references); - - return result && result.length > 0 ? result : undefined; - } - } -} From bb1f8f17db10f26b41538766b685aa62f6b50dee Mon Sep 17 00:00:00 2001 From: Reiner Dolp Date: Wed, 19 Apr 2017 19:36:19 +0100 Subject: [PATCH 09/17] fix issue 10452 --- src/lib/es5.d.ts | 63 ------------------------------------------------ 1 file changed, 63 deletions(-) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 69460f40c16..bef6feb660a 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1742,13 +1742,6 @@ interface Int8Array { */ reverse(): Int8Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -2033,13 +2026,6 @@ interface Uint8Array { */ reverse(): Uint8Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -2325,13 +2311,6 @@ interface Uint8ClampedArray { */ reverse(): Uint8ClampedArray; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -2616,13 +2595,6 @@ interface Int16Array { */ reverse(): Int16Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -2908,13 +2880,6 @@ interface Uint16Array { */ reverse(): Uint16Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -3199,13 +3164,6 @@ interface Int32Array { */ reverse(): Int32Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -3490,13 +3448,6 @@ interface Uint32Array { */ reverse(): Uint32Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -3781,13 +3732,6 @@ interface Float32Array { */ reverse(): Float32Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. @@ -4073,13 +4017,6 @@ interface Float64Array { */ reverse(): Float64Array; - /** - * Sets a value or an array of values. - * @param index The index of the location to set. - * @param value The value to set. - */ - set(index: number, value: number): void; - /** * Sets a value or an array of values. * @param array A typed or untyped array of values to set. From eb36455c8bac16155979b9596f106cdbabf1097f Mon Sep 17 00:00:00 2001 From: Reiner Dolp Date: Wed, 19 Apr 2017 19:37:37 +0100 Subject: [PATCH 10/17] fix issue 15275 --- src/lib/es5.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index bef6feb660a..23805495b69 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -2316,7 +2316,7 @@ interface Uint8ClampedArray { * @param array A typed or untyped array of values to set. * @param offset The index in the current array at which the values are to be written. */ - set(array: Uint8ClampedArray, offset?: number): void; + set(array: ArrayLike, offset?: number): void; /** * Returns a section of an array. From e8fd1cf4668f8f45e5d007b8050a1eddd65f5bb9 Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Wed, 19 Apr 2017 11:42:24 -0700 Subject: [PATCH 11/17] Support project root path for controlling config file searching depth (#15238) * stops at projectRootPath when searching config file * Add tests * Update editorServices.ts Remove extra `true &&` --- .../unittests/tsserverProjectSystem.ts | 24 +++++++++++++++++++ src/server/editorServices.ts | 16 ++++++------- src/server/protocol.ts | 5 ++++ src/server/session.ts | 10 +++++--- 4 files changed, 44 insertions(+), 11 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 66d9cb087b6..321ca9e3e0c 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -3493,6 +3493,30 @@ namespace ts.projectSystem { }); }); + describe("searching for config file", () => { + it("should stop at projectRootPath if given", () => { + const f1 = { + path: "/a/file1.ts", + content: "" + }; + const configFile = { + path: "/tsconfig.json", + content: "{}" + }; + const host = createServerHost([f1, configFile]); + const service = createProjectService(host); + service.openClientFile(f1.path, /*fileContent*/ undefined, /*scriptKind*/ undefined, "/a"); + + checkNumberOfConfiguredProjects(service, 0); + checkNumberOfInferredProjects(service, 1); + + service.closeClientFile(f1.path); + service.openClientFile(f1.path); + checkNumberOfConfiguredProjects(service, 1); + checkNumberOfInferredProjects(service, 0); + }); + }); + describe("cancellationToken", () => { it("is attached to request", () => { const f1 = { diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index d45bb283384..4699e1a1d4d 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -787,12 +787,12 @@ namespace ts.server { * we first detect if there is already a configured project created for it: if so, we re-read * the tsconfig file content and update the project; otherwise we create a new one. */ - private openOrUpdateConfiguredProjectForFile(fileName: NormalizedPath): OpenConfiguredProjectResult { + private openOrUpdateConfiguredProjectForFile(fileName: NormalizedPath, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult { const searchPath = getDirectoryPath(fileName); this.logger.info(`Search path: ${searchPath}`); // check if this file is already included in one of external projects - const configFileName = this.findConfigFile(asNormalizedPath(searchPath)); + const configFileName = this.findConfigFile(asNormalizedPath(searchPath), projectRootPath); if (!configFileName) { this.logger.info("No config files found."); return {}; @@ -826,8 +826,8 @@ namespace ts.server { // current directory (the directory in which tsc was invoked). // The server must start searching from the directory containing // the newly opened file. - private findConfigFile(searchPath: NormalizedPath): NormalizedPath { - while (true) { + private findConfigFile(searchPath: NormalizedPath, projectRootPath?: NormalizedPath): NormalizedPath { + while (!projectRootPath || searchPath.indexOf(projectRootPath) >= 0) { const tsconfigFileName = asNormalizedPath(combinePaths(searchPath, "tsconfig.json")); if (this.host.fileExists(tsconfigFileName)) { return tsconfigFileName; @@ -1326,17 +1326,17 @@ namespace ts.server { * @param filename is absolute pathname * @param fileContent is a known version of the file content that is more up to date than the one on disk */ - openClientFile(fileName: string, fileContent?: string, scriptKind?: ScriptKind): OpenConfiguredProjectResult { - return this.openClientFileWithNormalizedPath(toNormalizedPath(fileName), fileContent, scriptKind); + openClientFile(fileName: string, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: string): OpenConfiguredProjectResult { + return this.openClientFileWithNormalizedPath(toNormalizedPath(fileName), fileContent, scriptKind, /*hasMixedContent*/ false, projectRootPath ? toNormalizedPath(projectRootPath) : undefined); } - openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean): OpenConfiguredProjectResult { + openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult { let configFileName: NormalizedPath; let configFileErrors: Diagnostic[]; let project: ConfiguredProject | ExternalProject = this.findContainingExternalProject(fileName); if (!project) { - ({ configFileName, configFileErrors } = this.openOrUpdateConfiguredProjectForFile(fileName)); + ({ configFileName, configFileErrors } = this.openOrUpdateConfiguredProjectForFile(fileName, projectRootPath)); if (configFileName) { project = this.findConfiguredProjectByProjectName(configFileName); } diff --git a/src/server/protocol.ts b/src/server/protocol.ts index 71998666fed..8e3c6c2c07f 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -1041,6 +1041,11 @@ namespace ts.server.protocol { * "TS", "JS", "TSX", "JSX" */ scriptKindName?: ScriptKindName; + /** + * Used to limit the searching for project config file. If given the searching will stop at this + * root path; otherwise it will go all the way up to the dist root path. + */ + projectRootPath?: string; } export type ScriptKindName = "TS" | "JS" | "TSX" | "JSX"; diff --git a/src/server/session.ts b/src/server/session.ts index 742f8a3c228..194c6f667bb 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -979,8 +979,8 @@ namespace ts.server { * @param fileName is the name of the file to be opened * @param fileContent is a version of the file content that is known to be more up to date than the one on disk */ - private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind) { - const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind); + private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: NormalizedPath) { + const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, /*hasMixedContent*/ false, projectRootPath); if (this.eventHandler) { this.eventHandler({ eventName: "configFileDiag", @@ -1659,7 +1659,11 @@ namespace ts.server { return this.requiredResponse(this.getRenameInfo(request.arguments)); }, [CommandNames.Open]: (request: protocol.OpenRequest) => { - this.openClientFile(toNormalizedPath(request.arguments.file), request.arguments.fileContent, convertScriptKindName(request.arguments.scriptKindName)); + this.openClientFile( + toNormalizedPath(request.arguments.file), + request.arguments.fileContent, + convertScriptKindName(request.arguments.scriptKindName), + request.arguments.projectRootPath ? toNormalizedPath(request.arguments.projectRootPath) : undefined); return this.notRequired(); }, [CommandNames.Quickinfo]: (request: protocol.QuickInfoRequest) => { From 6749c77f36d57f7f2ab8c8b44d76145968d9c593 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 19 Apr 2017 13:22:49 -0700 Subject: [PATCH 12/17] check and emit fixes for async iteration --- src/compiler/checker.ts | 8 +-- src/compiler/transformers/esnext.ts | 10 +-- ...ter.asyncGenerators.classMethods.es2015.js | 63 ++++++++++--------- ...mitter.asyncGenerators.classMethods.es5.js | 63 ++++++++++--------- ...cGenerators.functionDeclarations.es2015.js | 53 ++++++++-------- ...syncGenerators.functionDeclarations.es5.js | 53 ++++++++-------- ...ncGenerators.functionExpressions.es2015.js | 53 ++++++++-------- ...asyncGenerators.functionExpressions.es5.js | 53 ++++++++-------- ...cGenerators.objectLiteralMethods.es2015.js | 53 ++++++++-------- ...syncGenerators.objectLiteralMethods.es5.js | 53 ++++++++-------- .../reference/emitter.forAwait.es2015.js | 10 ++- .../reference/emitter.forAwait.es5.js | 10 ++- 12 files changed, 249 insertions(+), 233 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0447e42ed64..f50e8aff474 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -19703,7 +19703,7 @@ namespace ts { } let iteratorMethodSignatures: Signature[]; - let mayBeIterable = false; + let isNonAsyncIterable = false; if (isAsyncIterable) { const iteratorMethod = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("asyncIterator")); if (isTypeAny(iteratorMethod)) { @@ -19718,17 +19718,17 @@ namespace ts { return undefined; } iteratorMethodSignatures = iteratorMethod && getSignaturesOfType(iteratorMethod, SignatureKind.Call); - mayBeIterable = true; + isNonAsyncIterable = true; } if (some(iteratorMethodSignatures)) { const iteratorMethodReturnType = getUnionType(map(iteratorMethodSignatures, getReturnTypeOfSignature), /*subtypeReduction*/ true); - const iteratedType = getIteratedTypeOfIterator(iteratorMethodReturnType, errorNode, /*isAsyncIterator*/ false); + const iteratedType = getIteratedTypeOfIterator(iteratorMethodReturnType, errorNode, /*isAsyncIterator*/ !isNonAsyncIterable); 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 + checkTypeAssignableTo(type, isNonAsyncIterable ? createIterableType(iteratedType) : createAsyncIterableType(iteratedType), errorNode); } diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index b43802c7a8f..9e68e48886f 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -891,9 +891,8 @@ namespace ts { 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -923,15 +922,16 @@ namespace ts { 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; ` }; function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { context.requestEmitHelper(asyncDelegator); + context.requestEmitHelper(asyncValues); return setTextRange( createCall( getHelperName("__asyncDelegator"), diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js index fe501f3c6be..e5a8800beef 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js @@ -68,9 +68,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -89,9 +88,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -111,9 +109,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -127,9 +124,14 @@ class C3 { } //// [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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -138,9 +140,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -160,17 +161,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; class C5 { f() { @@ -187,9 +192,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -209,9 +213,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -231,9 +234,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -255,9 +257,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js index a618c0787d2..67de0cff5df 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js @@ -95,9 +95,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -149,9 +148,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -209,9 +207,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -263,9 +260,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -274,9 +276,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -344,17 +345,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __values = (this && this.__values) || function (o) { var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; @@ -426,9 +431,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -486,9 +490,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -540,9 +543,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -607,9 +609,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js index 197a3d687c6..36e701072da 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js @@ -37,9 +37,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -56,9 +55,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -76,9 +74,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -90,9 +87,14 @@ function f3() { } //// [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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -101,9 +103,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -121,17 +122,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; function f5() { return __asyncGenerator(this, arguments, function* f5_1() { @@ -146,9 +151,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -166,9 +170,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js index 0dc0c02592e..4743e40b47b 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js @@ -64,9 +64,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -113,9 +112,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -168,9 +166,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -217,9 +214,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -228,9 +230,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -293,17 +294,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __values = (this && this.__values) || function (o) { var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; @@ -370,9 +375,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -425,9 +429,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js index 4e22d0c9922..b6bca871866 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js @@ -37,9 +37,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -56,9 +55,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -76,9 +74,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -90,9 +87,14 @@ const f3 = function () { }; //// [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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -101,9 +103,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -121,17 +122,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; const f5 = function () { return __asyncGenerator(this, arguments, function* () { @@ -146,9 +151,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -166,9 +170,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js index 986ba21fdd6..ec19e91e446 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js @@ -64,9 +64,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -113,9 +112,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -168,9 +166,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -217,9 +214,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -228,9 +230,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -293,17 +294,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __values = (this && this.__values) || function (o) { var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; @@ -370,9 +375,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -425,9 +429,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js index 2a8fccdc53a..f37428f20cb 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js @@ -51,9 +51,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -72,9 +71,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -94,9 +92,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -110,9 +107,14 @@ const o3 = { }; //// [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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -121,9 +123,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -143,17 +144,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; const o5 = { f() { @@ -170,9 +175,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -192,9 +196,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js index e0614ad763a..d3facb5b7cf 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js @@ -78,9 +78,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -129,9 +128,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -186,9 +184,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -237,9 +234,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) { } }; 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + 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) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -248,9 +250,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -315,17 +316,21 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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 }; }) }; + var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) }, p; 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 verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } +}; +var __asyncValues = (this && this.__asyncIterator) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator]; + return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator](); }; var __values = (this && this.__values) || function (o) { var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0; @@ -394,9 +399,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -451,9 +455,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.forAwait.es2015.js b/tests/baselines/reference/emitter.forAwait.es2015.js index b60627291e2..4bba2d06dcc 100644 --- a/tests/baselines/reference/emitter.forAwait.es2015.js +++ b/tests/baselines/reference/emitter.forAwait.es2015.js @@ -102,9 +102,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -140,9 +139,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } diff --git a/tests/baselines/reference/emitter.forAwait.es5.js b/tests/baselines/reference/emitter.forAwait.es5.js index a06d79b1dd5..09b73ed21f0 100644 --- a/tests/baselines/reference/emitter.forAwait.es5.js +++ b/tests/baselines/reference/emitter.forAwait.es5.js @@ -231,9 +231,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } @@ -320,9 +319,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? _yield : r.value[0] === "delegate" ? delegate : fulfill, reject); } - function _yield(value) { settle(c[2], { value: value, done: false }); } - function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); } + function step(r) { r.done ? settle(c[2], r) : Promise.resolve(r.value[1]).then(r.value[0] === "yield" ? send : fulfill, reject); } + function send(value) { settle(c[2], { value: 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(); } From 552f1d85c9f70be5d16efe8c3096f04bdb63eee5 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 19 Apr 2017 13:55:13 -0700 Subject: [PATCH 13/17] Revert changes to WeakSet defitions adding `object` constraint This reverts the changes to WeakSet done in https://github.com/Microsoft/TypeScript/pull/15124 to avoid breaks in existing @types packages like @types/lodash --- src/lib/es2015.collection.d.ts | 2 +- src/lib/es2015.iterable.d.ts | 2 +- src/lib/es2015.symbol.wellknown.d.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts index 038ed1ed58c..9b35fcbeffb 100644 --- a/src/lib/es2015.collection.d.ts +++ b/src/lib/es2015.collection.d.ts @@ -58,7 +58,7 @@ interface ReadonlySet { readonly size: number; } -interface WeakSet { +interface WeakSet { add(value: T): this; delete(value: T): boolean; has(value: T): boolean; diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index d242d14b663..2f8a1efba76 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -118,7 +118,7 @@ interface SetConstructor { new (iterable: Iterable): Set; } -interface WeakSet { } +interface WeakSet { } interface WeakSetConstructor { new (iterable: Iterable): WeakSet; diff --git a/src/lib/es2015.symbol.wellknown.d.ts b/src/lib/es2015.symbol.wellknown.d.ts index 3d030f37d49..578cf0acbc2 100644 --- a/src/lib/es2015.symbol.wellknown.d.ts +++ b/src/lib/es2015.symbol.wellknown.d.ts @@ -118,7 +118,7 @@ interface Set { readonly [Symbol.toStringTag]: "Set"; } -interface WeakSet { +interface WeakSet { readonly [Symbol.toStringTag]: "WeakSet"; } From 73142ff25c4c3543953d92a170d33fc2a6d4f158 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 19 Apr 2017 14:08:46 -0700 Subject: [PATCH 14/17] Handle rejection in async delegation --- src/compiler/transformers/esnext.ts | 2 +- .../reference/emitter.asyncGenerators.classMethods.es2015.js | 4 ++-- .../reference/emitter.asyncGenerators.classMethods.es5.js | 4 ++-- .../emitter.asyncGenerators.functionDeclarations.es2015.js | 4 ++-- .../emitter.asyncGenerators.functionDeclarations.es5.js | 4 ++-- .../emitter.asyncGenerators.functionExpressions.es2015.js | 4 ++-- .../emitter.asyncGenerators.functionExpressions.es5.js | 4 ++-- .../emitter.asyncGenerators.objectLiteralMethods.es2015.js | 4 ++-- .../emitter.asyncGenerators.objectLiteralMethods.es5.js | 4 ++-- 9 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index 9e68e48886f..3aa5be551a6 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -924,7 +924,7 @@ namespace ts { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; ` }; diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js index e5a8800beef..fbefef62d05 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js @@ -126,7 +126,7 @@ class C3 { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -170,7 +170,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js index 67de0cff5df..0c58c4735a0 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.js @@ -262,7 +262,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -354,7 +354,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js index 36e701072da..daf188ba33f 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js @@ -89,7 +89,7 @@ function f3() { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -131,7 +131,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js index 4743e40b47b..71f685e24dd 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.js @@ -216,7 +216,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -303,7 +303,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js index b6bca871866..bb2562db780 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js @@ -89,7 +89,7 @@ const f3 = function () { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -131,7 +131,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js index ec19e91e446..1863548c141 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.js @@ -216,7 +216,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -303,7 +303,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js index f37428f20cb..5a200349c02 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js @@ -109,7 +109,7 @@ const o3 = { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -153,7 +153,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js index d3facb5b7cf..abb3f0ca074 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.js @@ -236,7 +236,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); @@ -325,7 +325,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar 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 }; }) }, p; return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { return function (v) { return v = p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } + function verb(n, f) { return function (v) { return v = p && n === "throw" ? f(v) : p && v.done ? v : { value: p ? ["yield", v.value] : ["await", (o[n] || f).call(o, v)], done: false }, p = !p, v; }; } }; var __asyncValues = (this && this.__asyncIterator) || function (o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); From 96927379f0bac4e850f21b60678488cde8a88063 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 19 Apr 2017 14:53:32 -0700 Subject: [PATCH 15/17] Emit generated name for unnamed default exported class with decorated members --- src/compiler/transformers/ts.ts | 3 ++- .../decoratorOnClassAccessor1.es6.js | 20 ++++++++++++++++ .../decoratorOnClassAccessor1.es6.symbols | 17 ++++++++++++++ .../decoratorOnClassAccessor1.es6.types | 18 +++++++++++++++ .../reference/decoratorOnClassMethod1.es6.js | 20 ++++++++++++++++ .../decoratorOnClassMethod1.es6.symbols | 17 ++++++++++++++ .../decoratorOnClassMethod1.es6.types | 17 ++++++++++++++ .../decoratorOnClassMethodParameter1.es6.js | 23 +++++++++++++++++++ ...coratorOnClassMethodParameter1.es6.symbols | 14 +++++++++++ ...decoratorOnClassMethodParameter1.es6.types | 14 +++++++++++ .../decoratorOnClassProperty1.es6.js | 19 +++++++++++++++ .../decoratorOnClassProperty1.es6.symbols | 11 +++++++++ .../decoratorOnClassProperty1.es6.types | 11 +++++++++ .../accessor/decoratorOnClassAccessor1.es6.ts | 8 +++++++ .../method/decoratorOnClassMethod1.es6.ts | 8 +++++++ .../decoratorOnClassMethodParameter1.es6.ts | 8 +++++++ .../property/decoratorOnClassProperty1.es6.ts | 8 +++++++ 17 files changed, 235 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/decoratorOnClassAccessor1.es6.js create mode 100644 tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassAccessor1.es6.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod1.es6.js create mode 100644 tests/baselines/reference/decoratorOnClassMethod1.es6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod1.es6.types create mode 100644 tests/baselines/reference/decoratorOnClassMethodParameter1.es6.js create mode 100644 tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethodParameter1.es6.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty1.es6.js create mode 100644 tests/baselines/reference/decoratorOnClassProperty1.es6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassProperty1.es6.types create mode 100644 tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts create mode 100644 tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts create mode 100644 tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts create mode 100644 tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 18387d82611..780e519bb53 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -521,9 +521,10 @@ namespace ts { // emit name if // - node has a name // - node has static initializers + // - node has a member that is decorated // let name = node.name; - if (!name && staticProperties.length > 0) { + if (!name && (staticProperties.length > 0 || childIsDecorated(node))) { name = getGeneratedNameForNode(node); } diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.es6.js b/tests/baselines/reference/decoratorOnClassAccessor1.es6.js new file mode 100644 index 00000000000..484005b7a36 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassAccessor1.es6.js @@ -0,0 +1,20 @@ +//// [decoratorOnClassAccessor1.es6.ts] +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; + +export default class { + @dec get accessor() { return 1; } +} + +//// [decoratorOnClassAccessor1.es6.js] +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; +}; +export default class default_1 { + get accessor() { return 1; } +} +__decorate([ + dec +], default_1.prototype, "accessor", null); diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols b/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols new file mode 100644 index 00000000000..82fe1128ada --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassAccessor1.es6.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts === +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; +>dec : Symbol(dec, Decl(decoratorOnClassAccessor1.es6.ts, 0, 0)) +>T : Symbol(T, Decl(decoratorOnClassAccessor1.es6.ts, 0, 21)) +>target : Symbol(target, Decl(decoratorOnClassAccessor1.es6.ts, 0, 24)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor1.es6.ts, 0, 36)) +>descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor1.es6.ts, 0, 57)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(decoratorOnClassAccessor1.es6.ts, 0, 21)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(decoratorOnClassAccessor1.es6.ts, 0, 21)) + +export default class { + @dec get accessor() { return 1; } +>dec : Symbol(dec, Decl(decoratorOnClassAccessor1.es6.ts, 0, 0)) +>accessor : Symbol(default.accessor, Decl(decoratorOnClassAccessor1.es6.ts, 2, 22)) +} diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.es6.types b/tests/baselines/reference/decoratorOnClassAccessor1.es6.types new file mode 100644 index 00000000000..6a044d7a5ec --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassAccessor1.es6.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts === +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>T : T +>target : any +>propertyKey : string +>descriptor : TypedPropertyDescriptor +>TypedPropertyDescriptor : TypedPropertyDescriptor +>T : T +>TypedPropertyDescriptor : TypedPropertyDescriptor +>T : T + +export default class { + @dec get accessor() { return 1; } +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>accessor : number +>1 : 1 +} diff --git a/tests/baselines/reference/decoratorOnClassMethod1.es6.js b/tests/baselines/reference/decoratorOnClassMethod1.es6.js new file mode 100644 index 00000000000..6c518ae805e --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethod1.es6.js @@ -0,0 +1,20 @@ +//// [decoratorOnClassMethod1.es6.ts] +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; + +export default class { + @dec method() {} +} + +//// [decoratorOnClassMethod1.es6.js] +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; +}; +export default class default_1 { + method() { } +} +__decorate([ + dec +], default_1.prototype, "method", null); diff --git a/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols b/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols new file mode 100644 index 00000000000..1e7707c5329 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethod1.es6.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts === +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; +>dec : Symbol(dec, Decl(decoratorOnClassMethod1.es6.ts, 0, 0)) +>T : Symbol(T, Decl(decoratorOnClassMethod1.es6.ts, 0, 21)) +>target : Symbol(target, Decl(decoratorOnClassMethod1.es6.ts, 0, 24)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod1.es6.ts, 0, 36)) +>descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod1.es6.ts, 0, 57)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(decoratorOnClassMethod1.es6.ts, 0, 21)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(decoratorOnClassMethod1.es6.ts, 0, 21)) + +export default class { + @dec method() {} +>dec : Symbol(dec, Decl(decoratorOnClassMethod1.es6.ts, 0, 0)) +>method : Symbol(default.method, Decl(decoratorOnClassMethod1.es6.ts, 2, 22)) +} diff --git a/tests/baselines/reference/decoratorOnClassMethod1.es6.types b/tests/baselines/reference/decoratorOnClassMethod1.es6.types new file mode 100644 index 00000000000..83a7bfbb9ab --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethod1.es6.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts === +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>T : T +>target : any +>propertyKey : string +>descriptor : TypedPropertyDescriptor +>TypedPropertyDescriptor : TypedPropertyDescriptor +>T : T +>TypedPropertyDescriptor : TypedPropertyDescriptor +>T : T + +export default class { + @dec method() {} +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>method : () => void +} diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.js b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.js new file mode 100644 index 00000000000..b58c69150e5 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.js @@ -0,0 +1,23 @@ +//// [decoratorOnClassMethodParameter1.es6.ts] +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; + +export default class { + method(@dec p: number) {} +} + +//// [decoratorOnClassMethodParameter1.es6.js] +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 __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +export default class default_1 { + method(p) { } +} +__decorate([ + __param(0, dec) +], default_1.prototype, "method", null); diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols new file mode 100644 index 00000000000..aee56f5a4f8 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts === +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; +>dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 0)) +>target : Symbol(target, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 21)) +>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 36)) +>parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 66)) + +export default class { + method(@dec p: number) {} +>method : Symbol(default.method, Decl(decoratorOnClassMethodParameter1.es6.ts, 2, 22)) +>dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.es6.ts, 0, 0)) +>p : Symbol(p, Decl(decoratorOnClassMethodParameter1.es6.ts, 3, 11)) +} diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.types b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.types new file mode 100644 index 00000000000..0b66166bfaf --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts === +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; +>dec : (target: Object, propertyKey: string | symbol, parameterIndex: number) => void +>target : Object +>Object : Object +>propertyKey : string | symbol +>parameterIndex : number + +export default class { + method(@dec p: number) {} +>method : (p: number) => void +>dec : (target: Object, propertyKey: string | symbol, parameterIndex: number) => void +>p : number +} diff --git a/tests/baselines/reference/decoratorOnClassProperty1.es6.js b/tests/baselines/reference/decoratorOnClassProperty1.es6.js new file mode 100644 index 00000000000..81b72acf478 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty1.es6.js @@ -0,0 +1,19 @@ +//// [decoratorOnClassProperty1.es6.ts] +declare function dec(target: any, propertyKey: string): void; + +export default class { + @dec prop; +} + +//// [decoratorOnClassProperty1.es6.js] +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; +}; +export default class default_1 { +} +__decorate([ + dec +], default_1.prototype, "prop", void 0); diff --git a/tests/baselines/reference/decoratorOnClassProperty1.es6.symbols b/tests/baselines/reference/decoratorOnClassProperty1.es6.symbols new file mode 100644 index 00000000000..59db2c94cd0 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty1.es6.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts === +declare function dec(target: any, propertyKey: string): void; +>dec : Symbol(dec, Decl(decoratorOnClassProperty1.es6.ts, 0, 0)) +>target : Symbol(target, Decl(decoratorOnClassProperty1.es6.ts, 0, 21)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassProperty1.es6.ts, 0, 33)) + +export default class { + @dec prop; +>dec : Symbol(dec, Decl(decoratorOnClassProperty1.es6.ts, 0, 0)) +>prop : Symbol(default.prop, Decl(decoratorOnClassProperty1.es6.ts, 2, 22)) +} diff --git a/tests/baselines/reference/decoratorOnClassProperty1.es6.types b/tests/baselines/reference/decoratorOnClassProperty1.es6.types new file mode 100644 index 00000000000..96423d71d01 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty1.es6.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts === +declare function dec(target: any, propertyKey: string): void; +>dec : (target: any, propertyKey: string) => void +>target : any +>propertyKey : string + +export default class { + @dec prop; +>dec : (target: any, propertyKey: string) => void +>prop : any +} diff --git a/tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts b/tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts new file mode 100644 index 00000000000..774a28665fe --- /dev/null +++ b/tests/cases/conformance/es6/decorators/class/accessor/decoratorOnClassAccessor1.es6.ts @@ -0,0 +1,8 @@ +// @target: ES2015 +// @module: ES2015 +// @experimentaldecorators: true +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; + +export default class { + @dec get accessor() { return 1; } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts b/tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts new file mode 100644 index 00000000000..2e63e27086c --- /dev/null +++ b/tests/cases/conformance/es6/decorators/class/method/decoratorOnClassMethod1.es6.ts @@ -0,0 +1,8 @@ +// @target: ES2015 +// @module: ES2015 +// @experimentaldecorators: true +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; + +export default class { + @dec method() {} +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts b/tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts new file mode 100644 index 00000000000..344f49c89f9 --- /dev/null +++ b/tests/cases/conformance/es6/decorators/class/method/parameter/decoratorOnClassMethodParameter1.es6.ts @@ -0,0 +1,8 @@ +// @target: ES2015 +// @module: ES2015 +// @experimentaldecorators: true +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; + +export default class { + method(@dec p: number) {} +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts b/tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts new file mode 100644 index 00000000000..4f54960d2bc --- /dev/null +++ b/tests/cases/conformance/es6/decorators/class/property/decoratorOnClassProperty1.es6.ts @@ -0,0 +1,8 @@ +// @target: ES2015 +// @module: ES2015 +// @experimentaldecorators: true +declare function dec(target: any, propertyKey: string): void; + +export default class { + @dec prop; +} \ No newline at end of file From 6c176138ca7609b0abfa06cc3756339d2c7f8a36 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 19 Apr 2017 17:06:12 -0700 Subject: [PATCH 16/17] Fix loop block scope binding in generator --- src/compiler/transformers/es2015.ts | 9 +- ...blockScopedBindingsInDownlevelGenerator.js | 93 +++++++++++++++++++ ...ScopedBindingsInDownlevelGenerator.symbols | 14 +++ ...ckScopedBindingsInDownlevelGenerator.types | 22 +++++ ...blockScopedBindingsInDownlevelGenerator.ts | 9 ++ 5 files changed, 142 insertions(+), 5 deletions(-) create mode 100644 tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.js create mode 100644 tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.symbols create mode 100644 tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types create mode 100644 tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index f8ecf6bdcff..3ac5dc5d878 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -2714,9 +2714,8 @@ namespace ts { loopBody = createBlock([loopBody], /*multiline*/ true); } - const isAsyncBlockContainingAwait = - hierarchyFacts & HierarchyFacts.AsyncFunctionBody - && (node.statement.transformFlags & TransformFlags.ContainsYield) !== 0; + const containsYield = (node.statement.transformFlags & TransformFlags.ContainsYield) !== 0; + const isAsyncBlockContainingAwait = containsYield && (hierarchyFacts & HierarchyFacts.AsyncFunctionBody) !== 0; let loopBodyFlags: EmitFlags = 0; if (currentState.containsLexicalThis) { @@ -2739,7 +2738,7 @@ namespace ts { setEmitFlags( createFunctionExpression( /*modifiers*/ undefined, - isAsyncBlockContainingAwait ? createToken(SyntaxKind.AsteriskToken) : undefined, + containsYield ? createToken(SyntaxKind.AsteriskToken) : undefined, /*name*/ undefined, /*typeParameters*/ undefined, loopParameters, @@ -2833,7 +2832,7 @@ namespace ts { )); } - const convertedLoopBodyStatements = generateCallToConvertedLoop(functionName, loopParameters, currentState, isAsyncBlockContainingAwait); + const convertedLoopBodyStatements = generateCallToConvertedLoop(functionName, loopParameters, currentState, containsYield); let loop: Statement; if (convert) { diff --git a/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.js b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.js new file mode 100644 index 00000000000..be2bcd0bb0c --- /dev/null +++ b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.js @@ -0,0 +1,93 @@ +//// [blockScopedBindingsInDownlevelGenerator.ts] +function* a() { + for (const i of [1,2,3]) { + (() => i)() + yield i + } +} + +//// [blockScopedBindingsInDownlevelGenerator.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 __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 a() { + var _loop_1, _a, _b, i, e_1_1, e_1, _c; + return __generator(this, function (_d) { + switch (_d.label) { + case 0: + _loop_1 = function (i) { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + (function () { return i; })(); + return [4 /*yield*/, i]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; + _d.label = 1; + case 1: + _d.trys.push([1, 6, 7, 8]); + _a = __values([1, 2, 3]), _b = _a.next(); + _d.label = 2; + case 2: + if (!!_b.done) return [3 /*break*/, 5]; + i = _b.value; + return [5 /*yield**/, _loop_1(i)]; + case 3: + _d.sent(); + _d.label = 4; + case 4: + _b = _a.next(); + return [3 /*break*/, 2]; + case 5: return [3 /*break*/, 8]; + case 6: + e_1_1 = _d.sent(); + e_1 = { error: e_1_1 }; + return [3 /*break*/, 8]; + case 7: + try { + if (_b && !_b.done && (_c = _a.return)) _c.call(_a); + } + finally { if (e_1) throw e_1.error; } + return [7 /*endfinally*/]; + case 8: return [2 /*return*/]; + } + }); +} diff --git a/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.symbols b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.symbols new file mode 100644 index 00000000000..8caaed47a64 --- /dev/null +++ b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts === +function* a() { +>a : Symbol(a, Decl(blockScopedBindingsInDownlevelGenerator.ts, 0, 0)) + + for (const i of [1,2,3]) { +>i : Symbol(i, Decl(blockScopedBindingsInDownlevelGenerator.ts, 1, 12)) + + (() => i)() +>i : Symbol(i, Decl(blockScopedBindingsInDownlevelGenerator.ts, 1, 12)) + + yield i +>i : Symbol(i, Decl(blockScopedBindingsInDownlevelGenerator.ts, 1, 12)) + } +} diff --git a/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types new file mode 100644 index 00000000000..cf93e7c2f4d --- /dev/null +++ b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types @@ -0,0 +1,22 @@ +=== tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts === +function* a() { +>a : () => IterableIterator + + for (const i of [1,2,3]) { +>i : number +>[1,2,3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + + (() => i)() +>(() => i)() : number +>(() => i) : () => number +>() => i : () => number +>i : number + + yield i +>yield i : any +>i : number + } +} diff --git a/tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts b/tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts new file mode 100644 index 00000000000..ff2bb87149b --- /dev/null +++ b/tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts @@ -0,0 +1,9 @@ +// @target: es5 +// @downlevelIteration: true +// @lib: es2015 +function* a() { + for (const i of [1,2,3]) { + (() => i)() + yield i + } +} \ No newline at end of file From 420908eb6300e39d276680f8bbcdde7a93913650 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 19 Apr 2017 17:47:51 -0700 Subject: [PATCH 17/17] Change function name and clarify comment --- src/server/session.ts | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/src/server/session.ts b/src/server/session.ts index 57a3d0a5002..e5f79494553 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -25,11 +25,20 @@ namespace ts.server { return ((1e9 * seconds) + nanoseconds) / 1000000.0; } - function shouldSkipSemanticCheck(project: Project, file: NormalizedPath) { - // For inferred (e.g. miscellaneous context in VS) and external projects (e.g. VS .csproj project) with only JS files - // semantic errors in .d.ts files (e.g. ones added by automatic type acquisition) are not interesting. - // We want to avoid the cost of querying for these errors all together, even if 'skipLibCheck' is not set. - // We still want to check .js files (e.g. '// @ts-check' or '--checkJs' is set). + function isDeclarationFileInJSOnlyNonConfiguredProject(project: Project, file: NormalizedPath) { + // Checking for semantic diagnostics is an expensive process. We want to avoid it if we + // know for sure it is not needed. + // For instance, .d.ts files injected by ATA automatically do not produce any relevant + // errors to a JS- only project. + // + // Note that configured projects can set skipLibCheck (on by default in jsconfig.json) to + // disable checking for declaration files. We only need to verify for inferred projects (e.g. + // miscellaneous context in VS) and external projects(e.g.VS.csproj project) with only JS + // files. + // + // We still want to check .js files in a JS-only inferred or external project (e.g. if the + // file has '// @ts-check'). + if ((project.projectKind === ProjectKind.Inferred || project.projectKind === ProjectKind.External) && project.isJsOnlyProject()) { const scriptInfo = project.getScriptInfoForNormalizedPath(file); @@ -491,7 +500,7 @@ namespace ts.server { private semanticCheck(file: NormalizedPath, project: Project) { try { let diags: Diagnostic[] = []; - if (!shouldSkipSemanticCheck(project, file)) { + if (!isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) { diags = project.getLanguageService().getSemanticDiagnostics(file); } @@ -599,7 +608,7 @@ namespace ts.server { private getDiagnosticsWorker(args: protocol.FileRequestArgs, isSemantic: boolean, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) { const { project, file } = this.getFileAndProject(args); - if (isSemantic && shouldSkipSemanticCheck(project, file)) { + if (isSemantic && isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) { return []; } const scriptInfo = project.getScriptInfoForNormalizedPath(file);