From 3fef16008d2c29951476321144763b0ce9d5a777 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 11 Oct 2017 14:01:25 -0700 Subject: [PATCH 01/13] Fill missing type arguments during error reporting Previously, only the success path did this; it was missing in the error reporting path in resolveCall. This resulted in crashes for unsupplied type arguments when the supplied type arguments were incorrect. --- src/compiler/checker.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 36ee2a00eb9..56835e13dde 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -16203,8 +16203,10 @@ namespace ts { checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true); } else if (candidateForTypeArgumentError) { + const isJavascript = isInJavaScriptFile(candidateForTypeArgumentError.declaration); const typeArguments = (node).typeArguments; - checkTypeArguments(candidateForTypeArgumentError, typeArguments, map(typeArguments, getTypeFromTypeNode), /*reportErrors*/ true, fallbackError); + const typeArgumentTypes = fillMissingTypeArguments(map(typeArguments, getTypeFromTypeNode), candidateForTypeArgumentError.typeParameters, getMinTypeArgumentCount(candidateForTypeArgumentError.typeParameters), isJavascript); + checkTypeArguments(candidateForTypeArgumentError, typeArguments, typeArgumentTypes, /*reportErrors*/ true, fallbackError); } else if (typeArguments && every(signatures, sig => length(sig.typeParameters) !== typeArguments.length)) { let min = Number.POSITIVE_INFINITY; From 156e7e206969b63247944e420a0b6abda970c925 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 11 Oct 2017 14:02:20 -0700 Subject: [PATCH 02/13] Test:Incorrect number of type args during err reporting --- ...peArgumentsDuringErrorReporting.errors.txt | 28 ++++++++ ...mberOfTypeArgumentsDuringErrorReporting.js | 30 ++++++++ ...fTypeArgumentsDuringErrorReporting.symbols | 60 ++++++++++++++++ ...rOfTypeArgumentsDuringErrorReporting.types | 68 +++++++++++++++++++ ...mberOfTypeArgumentsDuringErrorReporting.ts | 21 ++++++ 5 files changed, 207 insertions(+) create mode 100644 tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.errors.txt create mode 100644 tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.js create mode 100644 tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.symbols create mode 100644 tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.types create mode 100644 tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts diff --git a/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.errors.txt b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.errors.txt new file mode 100644 index 00000000000..41aadb4d465 --- /dev/null +++ b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.errors.txt @@ -0,0 +1,28 @@ +tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts(18,4): error TS2559: Type 'MyObjA' has no properties in common with type 'ObjA'. + + +==== tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts (1 errors) ==== + interface ObjA { + y?:string, + } + + interface ObjB {[key:string]:any} + + interface Opts {a:A, b:B} + + const fn = < + A extends ObjA, + B extends ObjB = ObjB + >(opts:Opts):string => 'Z' + + interface MyObjA { + x:string, + } + + fn({ + ~~~~~~ +!!! error TS2559: Type 'MyObjA' has no properties in common with type 'ObjA'. + a: {x: 'X', y: 'Y'}, + b: {}, + }) + \ No newline at end of file diff --git a/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.js b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.js new file mode 100644 index 00000000000..d74360e8edc --- /dev/null +++ b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.js @@ -0,0 +1,30 @@ +//// [incorrectNumberOfTypeArgumentsDuringErrorReporting.ts] +interface ObjA { + y?:string, +} + +interface ObjB {[key:string]:any} + +interface Opts {a:A, b:B} + +const fn = < + A extends ObjA, + B extends ObjB = ObjB +>(opts:Opts):string => 'Z' + +interface MyObjA { + x:string, +} + +fn({ + a: {x: 'X', y: 'Y'}, + b: {}, +}) + + +//// [incorrectNumberOfTypeArgumentsDuringErrorReporting.js] +var fn = function (opts) { return 'Z'; }; +fn({ + a: { x: 'X', y: 'Y' }, + b: {} +}); diff --git a/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.symbols b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.symbols new file mode 100644 index 00000000000..5f94ad312c0 --- /dev/null +++ b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.symbols @@ -0,0 +1,60 @@ +=== tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts === +interface ObjA { +>ObjA : Symbol(ObjA, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 0, 0)) + + y?:string, +>y : Symbol(ObjA.y, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 0, 16)) +} + +interface ObjB {[key:string]:any} +>ObjB : Symbol(ObjB, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 2, 1)) +>key : Symbol(key, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 4, 17)) + +interface Opts {a:A, b:B} +>Opts : Symbol(Opts, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 4, 33)) +>A : Symbol(A, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 15)) +>B : Symbol(B, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 17)) +>a : Symbol(Opts.a, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 22)) +>A : Symbol(A, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 15)) +>b : Symbol(Opts.b, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 26)) +>B : Symbol(B, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 6, 17)) + +const fn = < +>fn : Symbol(fn, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 8, 5)) + + A extends ObjA, +>A : Symbol(A, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 8, 12)) +>ObjA : Symbol(ObjA, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 0, 0)) + + B extends ObjB = ObjB +>B : Symbol(B, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 9, 17)) +>ObjB : Symbol(ObjB, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 2, 1)) +>ObjB : Symbol(ObjB, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 2, 1)) + +>(opts:Opts):string => 'Z' +>opts : Symbol(opts, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 11, 2)) +>Opts : Symbol(Opts, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 4, 33)) +>A : Symbol(A, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 8, 12)) +>B : Symbol(B, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 9, 17)) + +interface MyObjA { +>MyObjA : Symbol(MyObjA, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 11, 32)) + + x:string, +>x : Symbol(MyObjA.x, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 13, 18)) +} + +fn({ +>fn : Symbol(fn, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 8, 5)) +>MyObjA : Symbol(MyObjA, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 11, 32)) + + a: {x: 'X', y: 'Y'}, +>a : Symbol(a, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 17, 12)) +>x : Symbol(x, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 18, 6)) +>y : Symbol(y, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 18, 13)) + + b: {}, +>b : Symbol(b, Decl(incorrectNumberOfTypeArgumentsDuringErrorReporting.ts, 18, 22)) + +}) + diff --git a/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.types b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.types new file mode 100644 index 00000000000..681a05eba09 --- /dev/null +++ b/tests/baselines/reference/incorrectNumberOfTypeArgumentsDuringErrorReporting.types @@ -0,0 +1,68 @@ +=== tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts === +interface ObjA { +>ObjA : ObjA + + y?:string, +>y : string +} + +interface ObjB {[key:string]:any} +>ObjB : ObjB +>key : string + +interface Opts {a:A, b:B} +>Opts : Opts +>A : A +>B : B +>a : A +>A : A +>b : B +>B : B + +const fn = < +>fn : (opts: Opts) => string +>< A extends ObjA, B extends ObjB = ObjB>(opts:Opts):string => 'Z' : (opts: Opts) => string + + A extends ObjA, +>A : A +>ObjA : ObjA + + B extends ObjB = ObjB +>B : B +>ObjB : ObjB +>ObjB : ObjB + +>(opts:Opts):string => 'Z' +>opts : Opts +>Opts : Opts +>A : A +>B : B +>'Z' : "Z" + +interface MyObjA { +>MyObjA : MyObjA + + x:string, +>x : string +} + +fn({ +>fn({ a: {x: 'X', y: 'Y'}, b: {},}) : any +>fn : (opts: Opts) => string +>MyObjA : MyObjA +>{ a: {x: 'X', y: 'Y'}, b: {},} : { a: { x: string; y: string; }; b: {}; } + + a: {x: 'X', y: 'Y'}, +>a : { x: string; y: string; } +>{x: 'X', y: 'Y'} : { x: string; y: string; } +>x : string +>'X' : "X" +>y : string +>'Y' : "Y" + + b: {}, +>b : {} +>{} : {} + +}) + diff --git a/tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts b/tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts new file mode 100644 index 00000000000..2f6c8c71250 --- /dev/null +++ b/tests/cases/compiler/incorrectNumberOfTypeArgumentsDuringErrorReporting.ts @@ -0,0 +1,21 @@ +interface ObjA { + y?:string, +} + +interface ObjB {[key:string]:any} + +interface Opts {a:A, b:B} + +const fn = < + A extends ObjA, + B extends ObjB = ObjB +>(opts:Opts):string => 'Z' + +interface MyObjA { + x:string, +} + +fn({ + a: {x: 'X', y: 'Y'}, + b: {}, +}) From 4d7c112ef7f5cd18f5563fff8158cc9e6eef6a98 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Wed, 11 Oct 2017 14:21:09 -0700 Subject: [PATCH 03/13] Make sure project root paths of inferred projects are canonical when comparing --- .../unittests/tsserverProjectSystem.ts | 111 +++++++++++++++++- src/server/editorServices.ts | 15 +-- src/server/project.ts | 6 +- .../reference/api/tsserverlibrary.d.ts | 3 +- 4 files changed, 124 insertions(+), 11 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index f7d082128cd..b52a6968774 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -220,11 +220,11 @@ namespace ts.projectSystem { checkNumberOfProjects(this, count); } } - export function createProjectService(host: server.ServerHost, parameters: CreateProjectServiceParameters = {}) { + export function createProjectService(host: server.ServerHost, parameters: CreateProjectServiceParameters = {}, options?: Partial) { const cancellationToken = parameters.cancellationToken || server.nullCancellationToken; const logger = parameters.logger || nullLogger; const useSingleInferredProject = parameters.useSingleInferredProject !== undefined ? parameters.useSingleInferredProject : false; - return new TestProjectService(host, logger, cancellationToken, useSingleInferredProject, parameters.typingsInstaller, parameters.eventHandler); + return new TestProjectService(host, logger, cancellationToken, useSingleInferredProject, parameters.typingsInstaller, parameters.eventHandler, options); } export function checkNumberOfConfiguredProjects(projectService: server.ProjectService, expected: number) { @@ -3703,6 +3703,113 @@ namespace ts.projectSystem { assert.equal(projectService.inferredProjects[1].getCompilationSettings().target, ScriptTarget.ESNext); assert.equal(projectService.inferredProjects[2].getCompilationSettings().target, ScriptTarget.ES2015); }); + + function checkInferredProject(inferredProject: server.InferredProject, actualFiles: FileOrFolder[], target: ScriptTarget) { + checkProjectActualFiles(inferredProject, actualFiles.map(f => f.path)); + assert.equal(inferredProject.getCompilationSettings().target, target); + } + + function verifyProjectRootWithCaseSensitivity(useCaseSensitiveFileNames: boolean) { + const files: [FileOrFolder, FileOrFolder, FileOrFolder, FileOrFolder] = [ + { path: "/a/file1.ts", content: "let x = 1;" }, + { path: "/A/file2.ts", content: "let y = 2;" }, + { path: "/b/file2.ts", content: "let x = 3;" }, + { path: "/c/file3.ts", content: "let z = 4;" } + ]; + const host = createServerHost(files, { useCaseSensitiveFileNames }); + const projectService = createProjectService(host, { useSingleInferredProject: true, }, { useInferredProjectPerProjectRoot: true }); + projectService.setCompilerOptionsForInferredProjects({ + allowJs: true, + target: ScriptTarget.ESNext + }); + projectService.setCompilerOptionsForInferredProjects({ + allowJs: true, + target: ScriptTarget.ES2015 + }, "/a"); + + openClientFiles(["/a", "/a", "/b", undefined]); + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0], files[1]], ScriptTarget.ES2015], + [[files[2]], ScriptTarget.ESNext] + ]); + closeClientFiles(); + + openClientFiles(["/a", "/A", "/b", undefined]); + if (useCaseSensitiveFileNames) { + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0]], ScriptTarget.ES2015], + [[files[1]], ScriptTarget.ESNext], + [[files[2]], ScriptTarget.ESNext] + ]); + } + else { + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0], files[1]], ScriptTarget.ES2015], + [[files[2]], ScriptTarget.ESNext] + ]); + } + closeClientFiles(); + + projectService.setCompilerOptionsForInferredProjects({ + allowJs: true, + target: ScriptTarget.ES2017 + }, "/A"); + + openClientFiles(["/a", "/a", "/b", undefined]); + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0], files[1]], useCaseSensitiveFileNames ? ScriptTarget.ES2015 : ScriptTarget.ES2017], + [[files[2]], ScriptTarget.ESNext] + ]); + closeClientFiles(); + + openClientFiles(["/a", "/A", "/b", undefined]); + if (useCaseSensitiveFileNames) { + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0]], ScriptTarget.ES2015], + [[files[1]], ScriptTarget.ES2017], + [[files[2]], ScriptTarget.ESNext] + ]); + } + else { + verifyInferredProjectsState([ + [[files[3]], ScriptTarget.ESNext], + [[files[0], files[1]], ScriptTarget.ES2017], + [[files[2]], ScriptTarget.ESNext] + ]); + } + closeClientFiles(); + + function openClientFiles(projectRoots: [string | undefined, string | undefined, string | undefined, string | undefined]) { + files.forEach((file, index) => { + projectService.openClientFile(file.path, file.content, ScriptKind.JS, projectRoots[index]); + }); + } + + function closeClientFiles() { + files.forEach(file => projectService.closeClientFile(file.path)); + } + + function verifyInferredProjectsState(expected: [FileOrFolder[], ScriptTarget][]) { + checkNumberOfProjects(projectService, { inferredProjects: expected.length }); + projectService.inferredProjects.forEach((p, index) => { + const [actualFiles, target] = expected[index]; + checkInferredProject(p, actualFiles, target); + }); + } + } + + it("inferred projects per project root with case sensitive system", () => { + verifyProjectRootWithCaseSensitivity(/*useCaseSensitiveFileNames*/ true); + }); + + it("inferred projects per project root with case insensitive system", () => { + verifyProjectRootWithCaseSensitivity(/*useCaseSensitiveFileNames*/ false); + }); }); describe("No overwrite emit error", () => { diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 379a5fbfe7e..98112b3f24e 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -590,9 +590,9 @@ namespace ts.server { // always set 'allowNonTsExtensions' for inferred projects since user cannot configure it from the outside // previously we did not expose a way for user to change these settings and this option was enabled by default compilerOptions.allowNonTsExtensions = true; - - if (projectRootPath) { - this.compilerOptionsForInferredProjectsPerProjectRoot.set(projectRootPath, compilerOptions); + const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath); + if (canonicalProjectRootPath) { + this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions); } else { this.compilerOptionsForInferredProjects = compilerOptions; @@ -608,9 +608,9 @@ namespace ts.server { // root path // - Inferred projects with a projectRootPath, if the new options apply to that // project root path. - if (projectRootPath ? - project.projectRootPath === projectRootPath : - !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) { + if (canonicalProjectRootPath ? + project.projectRootPath === canonicalProjectRootPath : + !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) { project.setCompilerOptions(compilerOptions); project.compileOnSaveEnabled = compilerOptions.compileOnSave; project.markAsDirty(); @@ -1596,9 +1596,10 @@ namespace ts.server { } if (projectRootPath) { + const canonicalProjectRootPath = this.toCanonicalFileName(projectRootPath); // if we have an explicit project root path, find (or create) the matching inferred project. for (const project of this.inferredProjects) { - if (project.projectRootPath === projectRootPath) { + if (project.projectRootPath === canonicalProjectRootPath) { return project; } } diff --git a/src/server/project.ts b/src/server/project.ts index 9c66f8b4a6c..bf060b66a27 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -1047,12 +1047,15 @@ namespace ts.server { super.setCompilerOptions(newOptions); } + /** this is canonical project root path */ + readonly projectRootPath: string | undefined; + /*@internal*/ constructor( projectService: ProjectService, documentRegistry: DocumentRegistry, compilerOptions: CompilerOptions, - readonly projectRootPath: string | undefined, + projectRootPath: string | undefined, currentDirectory: string | undefined) { super(InferredProject.newName(), ProjectKind.Inferred, @@ -1064,6 +1067,7 @@ namespace ts.server { /*compileOnSaveEnabled*/ false, projectService.host, currentDirectory); + this.projectRootPath = projectRootPath && projectService.toCanonicalFileName(projectRootPath); } addRoot(info: ScriptInfo) { diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index d862513c293..61320be7eb7 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -7186,11 +7186,12 @@ declare namespace ts.server { * the file and its imports/references are put into an InferredProject. */ class InferredProject extends Project { - readonly projectRootPath: string | undefined; private static readonly newName; private _isJsInferredProject; toggleJsInferredProject(isJsInferredProject: boolean): void; setCompilerOptions(options?: CompilerOptions): void; + /** this is canonical project root path*/ + readonly projectRootPath: string | undefined; addRoot(info: ScriptInfo): void; removeRoot(info: ScriptInfo): void; isProjectWithSingleRoot(): boolean; From d00ab417c6a4e5e084c3bbeab9b31ccd9fbc5854 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 11 Oct 2017 15:58:54 -0700 Subject: [PATCH 04/13] checkTypeParameters now always calls fillMissingTypeArguments And refactor checkTypeParameters to be easier to use and to read. --- src/compiler/checker.ts | 61 +++++++++++++++++++++-------------------- 1 file changed, 31 insertions(+), 30 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 56835e13dde..ff78ccaa135 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15643,34 +15643,35 @@ namespace ts { return getInferredTypes(context); } - function checkTypeArguments(signature: Signature, typeArgumentNodes: ReadonlyArray, typeArgumentTypes: Type[], reportErrors: boolean, headMessage?: DiagnosticMessage): boolean { + function checkTypeArguments(signature: Signature, typeArguments: ReadonlyArray, reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | false { + const isJavascript = isInJavaScriptFile(signature.declaration); const typeParameters = signature.typeParameters; - let typeArgumentsAreAssignable = true; + const typeArgumentTypes = fillMissingTypeArguments(map(typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); let mapper: TypeMapper; - for (let i = 0; i < typeArgumentNodes.length; i++) { - if (typeArgumentsAreAssignable /* so far */) { - const constraint = getConstraintOfTypeParameter(typeParameters[i]); - if (constraint) { - let errorInfo: DiagnosticMessageChain; - let typeArgumentHeadMessage = Diagnostics.Type_0_does_not_satisfy_the_constraint_1; - if (reportErrors && headMessage) { - errorInfo = chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); - typeArgumentHeadMessage = headMessage; - } - if (!mapper) { - mapper = createTypeMapper(typeParameters, typeArgumentTypes); - } - const typeArgument = typeArgumentTypes[i]; - typeArgumentsAreAssignable = checkTypeAssignableTo( - typeArgument, - getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), - reportErrors ? typeArgumentNodes[i] : undefined, - typeArgumentHeadMessage, - errorInfo); + for (let i = 0; i < typeArguments.length; i++) { + const constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + let errorInfo: DiagnosticMessageChain; + let typeArgumentHeadMessage = Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + if (!mapper) { + mapper = createTypeMapper(typeParameters, typeArgumentTypes); + } + const typeArgument = typeArgumentTypes[i]; + if (!checkTypeAssignableTo( + typeArgument, + getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), + reportErrors ? typeArguments[i] : undefined, + typeArgumentHeadMessage, + errorInfo)) { + return false; } } } - return typeArgumentsAreAssignable; + return typeArgumentTypes; } /** @@ -16203,10 +16204,7 @@ namespace ts { checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true); } else if (candidateForTypeArgumentError) { - const isJavascript = isInJavaScriptFile(candidateForTypeArgumentError.declaration); - const typeArguments = (node).typeArguments; - const typeArgumentTypes = fillMissingTypeArguments(map(typeArguments, getTypeFromTypeNode), candidateForTypeArgumentError.typeParameters, getMinTypeArgumentCount(candidateForTypeArgumentError.typeParameters), isJavascript); - checkTypeArguments(candidateForTypeArgumentError, typeArguments, typeArgumentTypes, /*reportErrors*/ true, fallbackError); + checkTypeArguments(candidateForTypeArgumentError, (node as CallExpression).typeArguments, /*reportErrors*/ true, fallbackError); } else if (typeArguments && every(signatures, sig => length(sig.typeParameters) !== typeArguments.length)) { let min = Number.POSITIVE_INFINITY; @@ -16305,10 +16303,12 @@ namespace ts { candidate = originalCandidate; if (candidate.typeParameters) { let typeArgumentTypes: Type[]; - const isJavascript = isInJavaScriptFile(candidate.declaration); if (typeArguments) { - typeArgumentTypes = fillMissingTypeArguments(map(typeArguments, getTypeFromTypeNode), candidate.typeParameters, getMinTypeArgumentCount(candidate.typeParameters), isJavascript); - if (!checkTypeArguments(candidate, typeArguments, typeArgumentTypes, /*reportErrors*/ false)) { + const typeArgumentResult = checkTypeArguments(candidate, typeArguments, /*reportErrors*/ false); + if (typeArgumentResult) { + typeArgumentTypes = typeArgumentResult; + } + else { candidateForTypeArgumentError = originalCandidate; break; } @@ -16316,6 +16316,7 @@ namespace ts { else { typeArgumentTypes = inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); } + const isJavascript = isInJavaScriptFile(candidate.declaration); candidate = getSignatureInstantiation(candidate, typeArgumentTypes, isJavascript); } if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) { From 625486455d5a4333fa564772c488b014f7967424 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Thu, 12 Oct 2017 09:02:22 -0700 Subject: [PATCH 05/13] Update public api baseline --- tests/baselines/reference/api/tsserverlibrary.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 61320be7eb7..baa7abbbd9c 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -7190,7 +7190,7 @@ declare namespace ts.server { private _isJsInferredProject; toggleJsInferredProject(isJsInferredProject: boolean): void; setCompilerOptions(options?: CompilerOptions): void; - /** this is canonical project root path*/ + /** this is canonical project root path */ readonly projectRootPath: string | undefined; addRoot(info: ScriptInfo): void; removeRoot(info: ScriptInfo): void; From 73826bdb7b921e1bf497f97e95ef9ce5e01e5857 Mon Sep 17 00:00:00 2001 From: Andrew Casey Date: Tue, 3 Oct 2017 15:39:12 -0700 Subject: [PATCH 06/13] Allow Extract Constant into enclosing scope in spite of RangeFacts.UsesThis --- src/harness/unittests/extractConstants.ts | 24 +++++++++++++++++ src/services/refactors/extractSymbol.ts | 5 +++- .../extractConstant_This_Constructor.js | 16 ++++++++++++ .../extractConstant_This_Constructor.ts | 26 +++++++++++++++++++ .../extractConstant_This_Method.js | 16 ++++++++++++ .../extractConstant_This_Method.ts | 26 +++++++++++++++++++ .../extractConstant_This_Property.ts | 18 +++++++++++++ tests/cases/fourslash/extract-method20.ts | 5 ++-- 8 files changed, 133 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/extractConstant/extractConstant_This_Constructor.js create mode 100644 tests/baselines/reference/extractConstant/extractConstant_This_Constructor.ts create mode 100644 tests/baselines/reference/extractConstant/extractConstant_This_Method.js create mode 100644 tests/baselines/reference/extractConstant/extractConstant_This_Method.ts create mode 100644 tests/baselines/reference/extractConstant/extractConstant_This_Property.ts diff --git a/src/harness/unittests/extractConstants.ts b/src/harness/unittests/extractConstants.ts index c5ddc18fea4..09f8db34f31 100644 --- a/src/harness/unittests/extractConstants.ts +++ b/src/harness/unittests/extractConstants.ts @@ -230,6 +230,30 @@ function f(): void { } testExtractConstantFailed("extractConstant_Never", ` function f(): never { } [#|f();|]`); + + testExtractConstant("extractConstant_This_Constructor", ` +class C { + constructor() { + [#|this.m2()|]; + } + m2() { return 1; } +}`); + + testExtractConstant("extractConstant_This_Method", ` +class C { + m1() { + [#|this.m2()|]; + } + m2() { return 1; } +}`); + + testExtractConstant("extractConstant_This_Property", ` +namespace N { // Force this test to be TS-only + class C { + x = 1; + y = [#|this.x|]; + } +}`); }); function testExtractConstant(caption: string, text: string) { diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index a03bb843600..9dd148e5420 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -476,7 +476,10 @@ namespace ts.refactor.extractSymbol { // if range uses this as keyword or as type inside the class then it can only be extracted to a method of the containing class const containingClass = getContainingClass(current); if (containingClass) { - return [containingClass]; + const containingFunction = findAncestor(current, isFunctionLikeDeclaration); + return containingFunction + ? [containingFunction, containingClass] + : [containingClass]; } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.js b/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.js new file mode 100644 index 00000000000..cf45ab2cd3f --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.js @@ -0,0 +1,16 @@ +// ==ORIGINAL== + +class C { + constructor() { + /*[#|*/this.m2()/*|]*/; + } + m2() { return 1; } +} +// ==SCOPE::Extract to constant in enclosing scope== + +class C { + constructor() { + const /*RENAME*/newLocal = this.m2(); + } + m2() { return 1; } +} \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.ts b/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.ts new file mode 100644 index 00000000000..d36d1a6fa21 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_This_Constructor.ts @@ -0,0 +1,26 @@ +// ==ORIGINAL== + +class C { + constructor() { + /*[#|*/this.m2()/*|]*/; + } + m2() { return 1; } +} +// ==SCOPE::Extract to constant in enclosing scope== + +class C { + constructor() { + const /*RENAME*/newLocal = this.m2(); + } + m2() { return 1; } +} +// ==SCOPE::Extract to readonly field in class 'C'== + +class C { + private readonly newProperty = this.m2(); + + constructor() { + this./*RENAME*/newProperty; + } + m2() { return 1; } +} \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_This_Method.js b/tests/baselines/reference/extractConstant/extractConstant_This_Method.js new file mode 100644 index 00000000000..fd703868e9f --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_This_Method.js @@ -0,0 +1,16 @@ +// ==ORIGINAL== + +class C { + m1() { + /*[#|*/this.m2()/*|]*/; + } + m2() { return 1; } +} +// ==SCOPE::Extract to constant in enclosing scope== + +class C { + m1() { + const /*RENAME*/newLocal = this.m2(); + } + m2() { return 1; } +} \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_This_Method.ts b/tests/baselines/reference/extractConstant/extractConstant_This_Method.ts new file mode 100644 index 00000000000..0dbaa4372d4 --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_This_Method.ts @@ -0,0 +1,26 @@ +// ==ORIGINAL== + +class C { + m1() { + /*[#|*/this.m2()/*|]*/; + } + m2() { return 1; } +} +// ==SCOPE::Extract to constant in enclosing scope== + +class C { + m1() { + const /*RENAME*/newLocal = this.m2(); + } + m2() { return 1; } +} +// ==SCOPE::Extract to readonly field in class 'C'== + +class C { + private readonly newProperty = this.m2(); + + m1() { + this./*RENAME*/newProperty; + } + m2() { return 1; } +} \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_This_Property.ts b/tests/baselines/reference/extractConstant/extractConstant_This_Property.ts new file mode 100644 index 00000000000..04b3b50da1b --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_This_Property.ts @@ -0,0 +1,18 @@ +// ==ORIGINAL== + +namespace N { // Force this test to be TS-only + class C { + x = 1; + y = /*[#|*/this.x/*|]*/; + } +} +// ==SCOPE::Extract to readonly field in class 'C'== + +namespace N { // Force this test to be TS-only + class C { + x = 1; + private readonly newProperty = this.x; + + y = this./*RENAME*/newProperty; + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/extract-method20.ts b/tests/cases/fourslash/extract-method20.ts index 75927f0fd5c..bd137c55d19 100644 --- a/tests/cases/fourslash/extract-method20.ts +++ b/tests/cases/fourslash/extract-method20.ts @@ -10,5 +10,6 @@ //// } goTo.select('a', 'b') -verify.refactorAvailable('Extract Symbol', 'function_scope_0'); -verify.not.refactorAvailable('Extract Symbol', 'function_scope_1'); +verify.not.refactorAvailable('Extract Symbol', 'function_scope_0'); +verify.refactorAvailable('Extract Symbol', 'function_scope_1'); +verify.not.refactorAvailable('Extract Symbol', 'function_scope_2'); From e4313f62c66375316dd9c6e979e770f3c36c8e27 Mon Sep 17 00:00:00 2001 From: Andrew Casey Date: Thu, 12 Oct 2017 09:44:02 -0700 Subject: [PATCH 07/13] Add missing test coverage for jumps in finally blocks --- src/harness/unittests/extractRanges.ts | 27 ++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/harness/unittests/extractRanges.ts b/src/harness/unittests/extractRanges.ts index 2ddcac482a9..a467bb23e0f 100644 --- a/src/harness/unittests/extractRanges.ts +++ b/src/harness/unittests/extractRanges.ts @@ -152,6 +152,16 @@ namespace ts { } } `); + testExtractRange(` + function f(x: number) { + [#|[$|try { + x++; + } + finally { + return 1; + }|]|] + } + `); }); testExtractRangeFailed("extractRangeFailed1", @@ -313,6 +323,23 @@ switch (x) { refactor.extractSymbol.Messages.CannotExtractRange.message ]); + testExtractRangeFailed("extractRangeFailed11", + ` + function f(x: number) { + while (true) { + [#|try { + x++; + } + finally { + break; + }|] + } + } + `, + [ + refactor.extractSymbol.Messages.CannotExtractRangeContainingConditionalBreakOrContinueStatements.message + ]); + testExtractRangeFailed("extract-method-not-for-token-expression-statement", `[#|a|]`, [refactor.extractSymbol.Messages.CannotExtractIdentifier.message]); }); } \ No newline at end of file From da0c79f2a3fe4793c00b1c47274c36e26a0ff2c4 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 12 Oct 2017 10:09:52 -0700 Subject: [PATCH 08/13] Simplify checkTypeArguments based on PR comments --- src/compiler/checker.ts | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ff78ccaa135..a58fa1cc9b5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15643,32 +15643,28 @@ namespace ts { return getInferredTypes(context); } - function checkTypeArguments(signature: Signature, typeArguments: ReadonlyArray, reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | false { + function checkTypeArguments(signature: Signature, typeArgumentNodes: ReadonlyArray, reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | false { const isJavascript = isInJavaScriptFile(signature.declaration); const typeParameters = signature.typeParameters; - const typeArgumentTypes = fillMissingTypeArguments(map(typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); + const typeArgumentTypes = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); let mapper: TypeMapper; - for (let i = 0; i < typeArguments.length; i++) { + for (let i = 0; i < typeArgumentNodes.length; i++) { const constraint = getConstraintOfTypeParameter(typeParameters[i]); - if (constraint) { - let errorInfo: DiagnosticMessageChain; - let typeArgumentHeadMessage = Diagnostics.Type_0_does_not_satisfy_the_constraint_1; - if (reportErrors && headMessage) { - errorInfo = chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); - typeArgumentHeadMessage = headMessage; - } - if (!mapper) { - mapper = createTypeMapper(typeParameters, typeArgumentTypes); - } - const typeArgument = typeArgumentTypes[i]; - if (!checkTypeAssignableTo( - typeArgument, - getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), - reportErrors ? typeArguments[i] : undefined, - typeArgumentHeadMessage, - errorInfo)) { - return false; - } + if (!constraint) continue; + + const errorInfo = reportErrors && headMessage && chainDiagnosticMessages(undefined, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + const typeArgumentHeadMessage = headMessage || Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (!mapper) { + mapper = createTypeMapper(typeParameters, typeArgumentTypes); + } + const typeArgument = typeArgumentTypes[i]; + if (!checkTypeAssignableTo( + typeArgument, + getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), + reportErrors ? typeArgumentNodes[i] : undefined, + typeArgumentHeadMessage, + errorInfo)) { + return false; } } return typeArgumentTypes; From 8ea13bef48cc276634e770009144995b843f5553 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 12 Oct 2017 10:11:09 -0700 Subject: [PATCH 09/13] Fix lint --- 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 a58fa1cc9b5..3380e89cd0f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15652,7 +15652,7 @@ namespace ts { const constraint = getConstraintOfTypeParameter(typeParameters[i]); if (!constraint) continue; - const errorInfo = reportErrors && headMessage && chainDiagnosticMessages(undefined, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + const errorInfo = reportErrors && headMessage && chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); const typeArgumentHeadMessage = headMessage || Diagnostics.Type_0_does_not_satisfy_the_constraint_1; if (!mapper) { mapper = createTypeMapper(typeParameters, typeArgumentTypes); From 27b4417304cebfc6fe22aeb747c0dca368ed906f Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 12 Oct 2017 10:38:02 -0700 Subject: [PATCH 10/13] Assert:checkTypeArguments isn't passed too many type arguments --- src/compiler/checker.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3380e89cd0f..3b6ef850ce8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15649,6 +15649,7 @@ namespace ts { const typeArgumentTypes = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); let mapper: TypeMapper; for (let i = 0; i < typeArgumentNodes.length; i++) { + Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments"); const constraint = getConstraintOfTypeParameter(typeParameters[i]); if (!constraint) continue; From 4de6b0dd2d104754ddca97d3c03e1819e0793668 Mon Sep 17 00:00:00 2001 From: Andrew Casey Date: Thu, 12 Oct 2017 11:34:34 -0700 Subject: [PATCH 11/13] Introduce and consume suppressLeadingAndTrailingTrivia Fixes #18626 --- src/compiler/factory.ts | 10 ++++++ src/harness/unittests/extractConstants.ts | 8 +++++ src/harness/unittests/extractFunctions.ts | 8 +++++ src/services/refactors/extractSymbol.ts | 18 +++++----- src/services/utilities.ts | 35 +++++++++++++++++++ .../extractConstant_PreserveTrivia.js | 17 +++++++++ .../extractConstant_PreserveTrivia.ts | 17 +++++++++ .../extractFunction/extractFunction13.ts | 6 ++-- .../extractFunction_PreserveTrivia.js | 19 ++++++++++ .../extractFunction_PreserveTrivia.ts | 19 ++++++++++ .../fourslash/extract-method-uniqueName.ts | 5 ++- 11 files changed, 146 insertions(+), 16 deletions(-) create mode 100644 tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.js create mode 100644 tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.ts create mode 100644 tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.js create mode 100644 tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.ts diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index fe183c5e806..65c1c92f366 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -2612,6 +2612,16 @@ namespace ts { return node; } + /** + * Sets flags that control emit behavior of a node. + */ + /* @internal */ + export function addEmitFlags(node: T, emitFlags: EmitFlags) { + const emitNode = getOrCreateEmitNode(node); + emitNode.flags = emitNode.flags | emitFlags; + return node; + } + /** * Gets a custom text range to use when emitting source maps. */ diff --git a/src/harness/unittests/extractConstants.ts b/src/harness/unittests/extractConstants.ts index 09f8db34f31..61ffbd01a63 100644 --- a/src/harness/unittests/extractConstants.ts +++ b/src/harness/unittests/extractConstants.ts @@ -223,6 +223,14 @@ const f = () => { testExtractConstant("extractConstant_ArrowFunction_Expression", `const f = () => [#|2 + 1|];`); + testExtractConstant("extractConstant_PreserveTrivia", ` +// a +var q = /*b*/ //c + /*d*/ [#|1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2|] /*k*/ //l + /*m*/; /*n*/ //o`); + testExtractConstantFailed("extractConstant_Void", ` function f(): void { } [#|f();|]`); diff --git a/src/harness/unittests/extractFunctions.ts b/src/harness/unittests/extractFunctions.ts index c69026c0be8..789882ffd50 100644 --- a/src/harness/unittests/extractFunctions.ts +++ b/src/harness/unittests/extractFunctions.ts @@ -532,6 +532,14 @@ function f() { [#|let x;|] return { x }; }`); + + testExtractFunction("extractFunction_PreserveTrivia", ` +// a +var q = /*b*/ //c + /*d*/ [#|1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2|] /*k*/ //l + /*m*/; /*n*/ //o`); }); function testExtractFunction(caption: string, text: string) { diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index 9dd148e5420..715b42b6bc8 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -740,6 +740,8 @@ namespace ts.refactor.extractSymbol { } const { body, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & RangeFacts.HasReturn)); + suppressLeadingAndTrailingTrivia(body); + let newFunction: MethodDeclaration | FunctionDeclaration; if (isClassLike(scope)) { @@ -926,15 +928,10 @@ namespace ts.refactor.extractSymbol { } } - if (isReadonlyArray(range.range)) { - changeTracker.replaceNodesWithNodes(context.file, range.range, newNodes, { - nodeSeparator: context.newLineCharacter, - suffix: context.newLineCharacter // insert newline only when replacing statements - }); - } - else { - changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes, { nodeSeparator: context.newLineCharacter }); - } + const replacementRange = isReadonlyArray(range.range) + ? { pos: first(range.range).getStart(), end: last(range.range).end } + : { pos: range.range.getStart(), end: range.range.end }; + changeTracker.replaceRangeWithNodes(context.file, replacementRange, newNodes, { nodeSeparator: context.newLineCharacter }); const edits = changeTracker.getChanges(); const renameRange = isReadonlyArray(range.range) ? first(range.range) : range.range; @@ -982,6 +979,7 @@ namespace ts.refactor.extractSymbol { : checker.typeToTypeNode(checker.getContextualType(node), scope, NodeBuilderFlags.NoTruncation); const initializer = transformConstantInitializer(node, substitutions); + suppressLeadingAndTrailingTrivia(initializer); const changeTracker = textChanges.ChangeTracker.fromContext(context); @@ -1014,7 +1012,7 @@ namespace ts.refactor.extractSymbol { changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariable, { suffix: context.newLineCharacter + context.newLineCharacter }); // Consume - changeTracker.replaceNodeWithNodes(context.file, node, [localReference], { nodeSeparator: context.newLineCharacter }); + changeTracker.replaceRange(context.file, { pos: node.getStart(), end: node.end }, localReference); } else { const newVariableDeclaration = createVariableDeclaration(localNameText, variableType, initializer); diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 0eb3f88cc9a..df3f3c5c6b4 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1369,4 +1369,39 @@ namespace ts { return visited; } + + /** + * Sets EmitFlags to suppress leading and trailing trivia on the node. + */ + /* @internal */ + export function suppressLeadingAndTrailingTrivia(node: Node) { + Debug.assert(node !== undefined); + + suppressLeading(node); + suppressTrailing(node); + + function suppressLeading(node: Node) { + addEmitFlags(node, EmitFlags.NoLeadingComments); + + const firstChild = forEachChild(node, child => child); + firstChild && suppressLeading(firstChild); + } + + function suppressTrailing(node: Node) { + addEmitFlags(node, EmitFlags.NoTrailingComments); + + let lastChild: Node = undefined; + forEachChild( + node, + child => (lastChild = child, undefined), + children => { + // As an optimization, jump straight to the end of the list. + if (children.length) { + lastChild = last(children); + } + return undefined; + }); + lastChild && suppressTrailing(lastChild); + } + } } diff --git a/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.js b/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.js new file mode 100644 index 00000000000..22abb77901d --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.js @@ -0,0 +1,17 @@ +// ==ORIGINAL== + +// a +var q = /*b*/ //c + /*d*/ /*[#|*/1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2/*|]*/ /*k*/ //l + /*m*/; /*n*/ //o +// ==SCOPE::Extract to constant in enclosing scope== +const newLocal = 1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2; + +// a +var q = /*b*/ //c + /*d*/ /*RENAME*/newLocal /*k*/ //l + /*m*/; /*n*/ //o \ No newline at end of file diff --git a/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.ts b/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.ts new file mode 100644 index 00000000000..22abb77901d --- /dev/null +++ b/tests/baselines/reference/extractConstant/extractConstant_PreserveTrivia.ts @@ -0,0 +1,17 @@ +// ==ORIGINAL== + +// a +var q = /*b*/ //c + /*d*/ /*[#|*/1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2/*|]*/ /*k*/ //l + /*m*/; /*n*/ //o +// ==SCOPE::Extract to constant in enclosing scope== +const newLocal = 1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2; + +// a +var q = /*b*/ //c + /*d*/ /*RENAME*/newLocal /*k*/ //l + /*m*/; /*n*/ //o \ No newline at end of file diff --git a/tests/baselines/reference/extractFunction/extractFunction13.ts b/tests/baselines/reference/extractFunction/extractFunction13.ts index 4987039d5da..662701ebf41 100644 --- a/tests/baselines/reference/extractFunction/extractFunction13.ts +++ b/tests/baselines/reference/extractFunction/extractFunction13.ts @@ -20,7 +20,7 @@ (u2a: U2a, u2b: U2b) => { function F2(t2a: T2a, t2b: T2b) { (u3a: U3a, u3b: U3b) => { - /*RENAME*/newFunction(u3a); + /*RENAME*/newFunction(u3a); } function newFunction(u3a: U3a) { @@ -40,7 +40,7 @@ (u2a: U2a, u2b: U2b) => { function F2(t2a: T2a, t2b: T2b) { (u3a: U3a, u3b: U3b) => { - /*RENAME*/newFunction(t2a, u2a, u3a); + /*RENAME*/newFunction(t2a, u2a, u3a); } } } @@ -60,7 +60,7 @@ (u2a: U2a, u2b: U2b) => { function F2(t2a: T2a, t2b: T2b) { (u3a: U3a, u3b: U3b) => { - /*RENAME*/newFunction(t1a, t2a, u1a, u2a, u3a); + /*RENAME*/newFunction(t1a, t2a, u1a, u2a, u3a); } } } diff --git a/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.js b/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.js new file mode 100644 index 00000000000..b5e4bc76c6e --- /dev/null +++ b/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.js @@ -0,0 +1,19 @@ +// ==ORIGINAL== + +// a +var q = /*b*/ //c + /*d*/ /*[#|*/1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2/*|]*/ /*k*/ //l + /*m*/; /*n*/ //o +// ==SCOPE::Extract to function in global scope== + +// a +var q = /*b*/ //c + /*d*/ /*RENAME*/newFunction() /*k*/ //l + /*m*/; /*n*/ //o +function newFunction() { + return 1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2; +} diff --git a/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.ts b/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.ts new file mode 100644 index 00000000000..b5e4bc76c6e --- /dev/null +++ b/tests/baselines/reference/extractFunction/extractFunction_PreserveTrivia.ts @@ -0,0 +1,19 @@ +// ==ORIGINAL== + +// a +var q = /*b*/ //c + /*d*/ /*[#|*/1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2/*|]*/ /*k*/ //l + /*m*/; /*n*/ //o +// ==SCOPE::Extract to function in global scope== + +// a +var q = /*b*/ //c + /*d*/ /*RENAME*/newFunction() /*k*/ //l + /*m*/; /*n*/ //o +function newFunction() { + return 1 /*e*/ //f + /*g*/ + /*h*/ //i + /*j*/ 2; +} diff --git a/tests/cases/fourslash/extract-method-uniqueName.ts b/tests/cases/fourslash/extract-method-uniqueName.ts index 4271d9e84d2..da4c68cfb7e 100644 --- a/tests/cases/fourslash/extract-method-uniqueName.ts +++ b/tests/cases/fourslash/extract-method-uniqueName.ts @@ -11,10 +11,9 @@ edit.applyRefactor({ actionName: "function_scope_0", actionDescription: "Extract to function in global scope", newContent: -`/*RENAME*/newFunction_1(); - +`// newFunction +/*RENAME*/newFunction_1(); function newFunction_1() { - // newFunction 1 + 1; } ` From 9af21eb00eb957240159745c181077e21df9da17 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 12 Oct 2017 12:53:12 -0700 Subject: [PATCH 12/13] Transform nested dynamic imports (#18998) * Fix nested dynamic imports when targeting es6 * Fixup nested dynamic imports when targeting downlevel * Remove duplicated expressions in UMD emit * Code review feedback, clone arg if need be * More CR feedback, apply user quotemark styles * Remove blank lines * Use behavior of visitEachChild instead of enw codepath, add new test, use createLiteral to retain quotemarks * Set lib flag for test --- src/compiler/transformers/generators.ts | 3 +- src/compiler/transformers/module/module.ts | 46 ++++++---- src/compiler/transformers/module/system.ts | 2 +- src/compiler/transformers/utilities.ts | 13 +++ .../reference/asyncImportNestedYield.js | 58 +++++++++++++ .../reference/asyncImportNestedYield.symbols | 6 ++ .../reference/asyncImportNestedYield.types | 14 ++++ .../dynamicImportWithNestedThis_es2015.js | 3 +- .../dynamicImportWithNestedThis_es5.js | 3 +- .../importCallExpressionGrammarError.js | 2 +- .../importCallExpressionNestedAMD.js | 33 ++++++++ .../importCallExpressionNestedAMD.symbols | 12 +++ .../importCallExpressionNestedAMD.types | 17 ++++ .../importCallExpressionNestedAMD2.js | 66 +++++++++++++++ .../importCallExpressionNestedAMD2.symbols | 12 +++ .../importCallExpressionNestedAMD2.types | 17 ++++ .../importCallExpressionNestedCJS.js | 28 +++++++ .../importCallExpressionNestedCJS.symbols | 12 +++ .../importCallExpressionNestedCJS.types | 17 ++++ .../importCallExpressionNestedCJS2.js | 61 ++++++++++++++ .../importCallExpressionNestedCJS2.symbols | 12 +++ .../importCallExpressionNestedCJS2.types | 17 ++++ ...mportCallExpressionNestedES2015.errors.txt | 15 ++++ .../importCallExpressionNestedES2015.js | 26 ++++++ .../importCallExpressionNestedES2015.symbols | 12 +++ .../importCallExpressionNestedES2015.types | 17 ++++ ...portCallExpressionNestedES20152.errors.txt | 15 ++++ .../importCallExpressionNestedES20152.js | 59 +++++++++++++ .../importCallExpressionNestedES20152.symbols | 12 +++ .../importCallExpressionNestedES20152.types | 17 ++++ .../importCallExpressionNestedESNext.js | 26 ++++++ .../importCallExpressionNestedESNext.symbols | 12 +++ .../importCallExpressionNestedESNext.types | 17 ++++ .../importCallExpressionNestedESNext2.js | 59 +++++++++++++ .../importCallExpressionNestedESNext2.symbols | 12 +++ .../importCallExpressionNestedESNext2.types | 17 ++++ .../importCallExpressionNestedSystem.js | 43 ++++++++++ .../importCallExpressionNestedSystem.symbols | 12 +++ .../importCallExpressionNestedSystem.types | 17 ++++ .../importCallExpressionNestedSystem2.js | 76 +++++++++++++++++ .../importCallExpressionNestedSystem2.symbols | 12 +++ .../importCallExpressionNestedSystem2.types | 17 ++++ .../importCallExpressionNestedUMD.js | 51 +++++++++++ .../importCallExpressionNestedUMD.symbols | 12 +++ .../importCallExpressionNestedUMD.types | 17 ++++ .../importCallExpressionNestedUMD2.js | 84 +++++++++++++++++++ .../importCallExpressionNestedUMD2.symbols | 12 +++ .../importCallExpressionNestedUMD2.types | 17 ++++ .../cases/compiler/asyncImportNestedYield.ts | 4 + .../importCallExpressionNestedAMD.ts | 11 +++ .../importCallExpressionNestedAMD2.ts | 11 +++ .../importCallExpressionNestedCJS.ts | 11 +++ .../importCallExpressionNestedCJS2.ts | 11 +++ .../importCallExpressionNestedES2015.ts | 11 +++ .../importCallExpressionNestedES20152.ts | 11 +++ .../importCallExpressionNestedESNext.ts | 11 +++ .../importCallExpressionNestedESNext2.ts | 11 +++ .../importCallExpressionNestedSystem.ts | 11 +++ .../importCallExpressionNestedSystem2.ts | 11 +++ .../importCallExpressionNestedUMD.ts | 11 +++ .../importCallExpressionNestedUMD2.ts | 11 +++ 61 files changed, 1254 insertions(+), 22 deletions(-) create mode 100644 tests/baselines/reference/asyncImportNestedYield.js create mode 100644 tests/baselines/reference/asyncImportNestedYield.symbols create mode 100644 tests/baselines/reference/asyncImportNestedYield.types create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD.js create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD.types create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD2.js create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD2.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedAMD2.types create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS.js create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS.types create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS2.js create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS2.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedCJS2.types create mode 100644 tests/baselines/reference/importCallExpressionNestedES2015.errors.txt create mode 100644 tests/baselines/reference/importCallExpressionNestedES2015.js create mode 100644 tests/baselines/reference/importCallExpressionNestedES2015.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedES2015.types create mode 100644 tests/baselines/reference/importCallExpressionNestedES20152.errors.txt create mode 100644 tests/baselines/reference/importCallExpressionNestedES20152.js create mode 100644 tests/baselines/reference/importCallExpressionNestedES20152.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedES20152.types create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext.js create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext.types create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext2.js create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext2.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedESNext2.types create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem.js create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem.types create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem2.js create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem2.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedSystem2.types create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD.js create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD.types create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD2.js create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD2.symbols create mode 100644 tests/baselines/reference/importCallExpressionNestedUMD2.types create mode 100644 tests/cases/compiler/asyncImportNestedYield.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD2.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS2.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedES2015.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedES20152.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext2.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem2.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD.ts create mode 100644 tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD2.ts diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index 84ed997a70e..7ede62b1540 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -1112,7 +1112,7 @@ namespace ts { } function visitCallExpression(node: CallExpression) { - if (forEach(node.arguments, containsYield)) { + if (!isImportCall(node) && forEach(node.arguments, containsYield)) { // [source] // a.b(1, yield, 2); // @@ -1123,7 +1123,6 @@ namespace ts { // .yield resumeLabel // .mark resumeLabel // _b.apply(_a, _c.concat([%sent%, 2])); - const { target, thisArg } = createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, /*cacheIdentifiers*/ true); return setOriginalNode( createFunctionApply( diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index ba262bf2c59..bd360fdffe4 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -21,7 +21,8 @@ namespace ts { const { startLexicalEnvironment, - endLexicalEnvironment + endLexicalEnvironment, + hoistVariableDeclaration } = context; const compilerOptions = context.getCompilerOptions(); @@ -519,18 +520,20 @@ namespace ts { } function visitImportCallExpression(node: ImportCall): Expression { + const argument = visitNode(firstOrUndefined(node.arguments), importCallExpressionVisitor); + const containsLexicalThis = !!(node.transformFlags & TransformFlags.ContainsLexicalThis); switch (compilerOptions.module) { case ModuleKind.AMD: - return transformImportCallExpressionAMD(node); + return createImportCallExpressionAMD(argument, containsLexicalThis); case ModuleKind.UMD: - return transformImportCallExpressionUMD(node); + return createImportCallExpressionUMD(argument, containsLexicalThis); case ModuleKind.CommonJS: default: - return transformImportCallExpressionCommonJS(node); + return createImportCallExpressionCommonJS(argument, containsLexicalThis); } } - function transformImportCallExpressionUMD(node: ImportCall): Expression { + function createImportCallExpressionUMD(arg: Expression | undefined, containsLexicalThis: boolean): Expression { // (function (factory) { // ... (regular UMD) // } @@ -545,14 +548,25 @@ namespace ts { // : new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/ // }); needUMDDynamicImportHelper = true; - return createConditional( - /*condition*/ createIdentifier("__syncRequire"), - /*whenTrue*/ transformImportCallExpressionCommonJS(node), - /*whenFalse*/ transformImportCallExpressionAMD(node) - ); + if (isSimpleCopiableExpression(arg)) { + const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? createLiteral(arg) : setEmitFlags(setTextRange(getSynthesizedClone(arg), arg), EmitFlags.NoComments); + return createConditional( + /*condition*/ createIdentifier("__syncRequire"), + /*whenTrue*/ createImportCallExpressionCommonJS(arg, containsLexicalThis), + /*whenFalse*/ createImportCallExpressionAMD(argClone, containsLexicalThis) + ); + } + else { + const temp = createTempVariable(hoistVariableDeclaration); + return createComma(createAssignment(temp, arg), createConditional( + /*condition*/ createIdentifier("__syncRequire"), + /*whenTrue*/ createImportCallExpressionCommonJS(temp, containsLexicalThis), + /*whenFalse*/ createImportCallExpressionAMD(temp, containsLexicalThis) + )); + } } - function transformImportCallExpressionAMD(node: ImportCall): Expression { + function createImportCallExpressionAMD(arg: Expression | undefined, containsLexicalThis: boolean): Expression { // improt("./blah") // emit as // define(["require", "exports", "blah"], function (require, exports) { @@ -570,7 +584,7 @@ namespace ts { createCall( createIdentifier("require"), /*typeArguments*/ undefined, - [createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject] + [createArrayLiteral([arg || createOmittedExpression()]), resolve, reject] ) ) ]); @@ -598,7 +612,7 @@ namespace ts { // if there is a lexical 'this' in the import call arguments, ensure we indicate // that this new function expression indicates it captures 'this' so that the // es2015 transformer will properly substitute 'this' with '_this'. - if (node.transformFlags & TransformFlags.ContainsLexicalThis) { + if (containsLexicalThis) { setEmitFlags(func, EmitFlags.CapturesThis); } } @@ -606,14 +620,14 @@ namespace ts { return createNew(createIdentifier("Promise"), /*typeArguments*/ undefined, [func]); } - function transformImportCallExpressionCommonJS(node: ImportCall): Expression { + function createImportCallExpressionCommonJS(arg: Expression | undefined, containsLexicalThis: boolean): Expression { // import("./blah") // emit as // Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/ // We have to wrap require in then callback so that require is done in asynchronously // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately const promiseResolveCall = createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []); - const requireCall = createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments); + const requireCall = createCall(createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []); let func: FunctionExpression | ArrowFunction; if (languageVersion >= ScriptTarget.ES2015) { @@ -638,7 +652,7 @@ namespace ts { // if there is a lexical 'this' in the import call arguments, ensure we indicate // that this new function expression indicates it captures 'this' so that the // es2015 transformer will properly substitute 'this' with '_this'. - if (node.transformFlags & TransformFlags.ContainsLexicalThis) { + if (containsLexicalThis) { setEmitFlags(func, EmitFlags.CapturesThis); } } diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index af77c499e8d..ed943eb90ce 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -1495,7 +1495,7 @@ namespace ts { createIdentifier("import") ), /*typeArguments*/ undefined, - node.arguments + some(node.arguments) ? [visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : [] ); } diff --git a/src/compiler/transformers/utilities.ts b/src/compiler/transformers/utilities.ts index 00a0753eaa1..a012c9be7db 100644 --- a/src/compiler/transformers/utilities.ts +++ b/src/compiler/transformers/utilities.ts @@ -178,4 +178,17 @@ namespace ts { } return values; } + + /** + * Used in the module transformer to check if an expression is reasonably without sideeffect, + * and thus better to copy into multiple places rather than to cache in a temporary variable + * - this is mostly subjective beyond the requirement that the expression not be sideeffecting + */ + export function isSimpleCopiableExpression(expression: Expression) { + return expression.kind === SyntaxKind.StringLiteral || + expression.kind === SyntaxKind.NumericLiteral || + expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral || + isKeyword(expression.kind) || + isIdentifier(expression); + } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncImportNestedYield.js b/tests/baselines/reference/asyncImportNestedYield.js new file mode 100644 index 00000000000..0dd76a13ace --- /dev/null +++ b/tests/baselines/reference/asyncImportNestedYield.js @@ -0,0 +1,58 @@ +//// [asyncImportNestedYield.ts] +async function* foo() { + import((await import(yield "foo")).default); +} + +//// [asyncImportNestedYield.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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +function foo() { + return __asyncGenerator(this, arguments, function foo_1() { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, "foo"]; + case 1: return [4 /*yield*/, __await.apply(void 0, [Promise.resolve().then(function () { return require(_a.sent()); })])]; + case 2: + Promise.resolve().then(function () { return require((_a.sent())["default"]); }); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/asyncImportNestedYield.symbols b/tests/baselines/reference/asyncImportNestedYield.symbols new file mode 100644 index 00000000000..01107ba5bf6 --- /dev/null +++ b/tests/baselines/reference/asyncImportNestedYield.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/asyncImportNestedYield.ts === +async function* foo() { +>foo : Symbol(foo, Decl(asyncImportNestedYield.ts, 0, 0)) + + import((await import(yield "foo")).default); +} diff --git a/tests/baselines/reference/asyncImportNestedYield.types b/tests/baselines/reference/asyncImportNestedYield.types new file mode 100644 index 00000000000..872e3141500 --- /dev/null +++ b/tests/baselines/reference/asyncImportNestedYield.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/asyncImportNestedYield.ts === +async function* foo() { +>foo : () => AsyncIterableIterator<"foo"> + + import((await import(yield "foo")).default); +>import((await import(yield "foo")).default) : Promise +>(await import(yield "foo")).default : any +>(await import(yield "foo")) : any +>await import(yield "foo") : any +>import(yield "foo") : Promise +>yield "foo" : any +>"foo" : "foo" +>default : any +} diff --git a/tests/baselines/reference/dynamicImportWithNestedThis_es2015.js b/tests/baselines/reference/dynamicImportWithNestedThis_es2015.js index 86fba0c0b5d..4f79e0caec1 100644 --- a/tests/baselines/reference/dynamicImportWithNestedThis_es2015.js +++ b/tests/baselines/reference/dynamicImportWithNestedThis_es2015.js @@ -29,7 +29,8 @@ c.dynamic(); this._path = './other'; } dynamic() { - return __syncRequire ? Promise.resolve().then(() => require(this._path)) : new Promise((resolve_1, reject_1) => { require([this._path], resolve_1, reject_1); }); + return _a = this._path, __syncRequire ? Promise.resolve().then(() => require(_a)) : new Promise((resolve_1, reject_1) => { require([_a], resolve_1, reject_1); }); + var _a; } } const c = new C(); diff --git a/tests/baselines/reference/dynamicImportWithNestedThis_es5.js b/tests/baselines/reference/dynamicImportWithNestedThis_es5.js index cde1979b25b..fcfde9e9887 100644 --- a/tests/baselines/reference/dynamicImportWithNestedThis_es5.js +++ b/tests/baselines/reference/dynamicImportWithNestedThis_es5.js @@ -30,7 +30,8 @@ c.dynamic(); } C.prototype.dynamic = function () { var _this = this; - return __syncRequire ? Promise.resolve().then(function () { return require(_this._path); }) : new Promise(function (resolve_1, reject_1) { require([_this._path], resolve_1, reject_1); }); + return _a = this._path, __syncRequire ? Promise.resolve().then(function () { return require(_a); }) : new Promise(function (resolve_1, reject_1) { require([_a], resolve_1, reject_1); }); + var _a; }; return C; }()); diff --git a/tests/baselines/reference/importCallExpressionGrammarError.js b/tests/baselines/reference/importCallExpressionGrammarError.js index e2ffc55577d..435eab35d4e 100644 --- a/tests/baselines/reference/importCallExpressionGrammarError.js +++ b/tests/baselines/reference/importCallExpressionGrammarError.js @@ -16,4 +16,4 @@ Promise.resolve().then(() => require(...["PathModule"])); var p1 = Promise.resolve().then(() => require(...a)); const p2 = Promise.resolve().then(() => require()); const p3 = Promise.resolve().then(() => require()); -const p4 = Promise.resolve().then(() => require("pathToModule", "secondModule")); +const p4 = Promise.resolve().then(() => require("pathToModule")); diff --git a/tests/baselines/reference/importCallExpressionNestedAMD.js b/tests/baselines/reference/importCallExpressionNestedAMD.js new file mode 100644 index 00000000000..dc211d44003 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD.js @@ -0,0 +1,33 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = "./foo"; +}); +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +define(["require", "exports"], function (require, exports) { + "use strict"; + function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield new Promise((resolve_1, reject_1) => { require([(yield new Promise((resolve_2, reject_2) => { require(["./foo"], resolve_2, reject_2); })).default], resolve_1, reject_1); }); + }); + } +}); diff --git a/tests/baselines/reference/importCallExpressionNestedAMD.symbols b/tests/baselines/reference/importCallExpressionNestedAMD.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedAMD.types b/tests/baselines/reference/importCallExpressionNestedAMD.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedAMD2.js b/tests/baselines/reference/importCallExpressionNestedAMD2.js new file mode 100644 index 00000000000..1e159af2180 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD2.js @@ -0,0 +1,66 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD2.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = "./foo"; +}); +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +define(["require", "exports"], function (require, exports) { + "use strict"; + function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, new Promise(function (resolve_1, reject_1) { require(["./foo"], resolve_1, reject_1); })]; + case 1: return [4 /*yield*/, new Promise(function (resolve_2, reject_2) { require([(_a.sent()).default], resolve_2, reject_2); })]; + case 2: return [2 /*return*/, _a.sent()]; + } + }); + }); + } +}); diff --git a/tests/baselines/reference/importCallExpressionNestedAMD2.symbols b/tests/baselines/reference/importCallExpressionNestedAMD2.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD2.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedAMD2.types b/tests/baselines/reference/importCallExpressionNestedAMD2.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedAMD2.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS.js b/tests/baselines/reference/importCallExpressionNestedCJS.js new file mode 100644 index 00000000000..07c0f234bf7 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS.js @@ -0,0 +1,28 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield Promise.resolve().then(() => require((yield Promise.resolve().then(() => require("./foo"))).default)); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS.symbols b/tests/baselines/reference/importCallExpressionNestedCJS.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS.types b/tests/baselines/reference/importCallExpressionNestedCJS.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS2.js b/tests/baselines/reference/importCallExpressionNestedCJS2.js new file mode 100644 index 00000000000..c76044ec05c --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS2.js @@ -0,0 +1,61 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS2.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require("./foo"); })]; + case 1: return [4 /*yield*/, Promise.resolve().then(function () { return require((_a.sent()).default); })]; + case 2: return [2 /*return*/, _a.sent()]; + } + }); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS2.symbols b/tests/baselines/reference/importCallExpressionNestedCJS2.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS2.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedCJS2.types b/tests/baselines/reference/importCallExpressionNestedCJS2.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedCJS2.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedES2015.errors.txt b/tests/baselines/reference/importCallExpressionNestedES2015.errors.txt new file mode 100644 index 00000000000..1208dd0c709 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES2015.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/dynamicImport/index.ts(2,18): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. +tests/cases/conformance/dynamicImport/index.ts(2,32): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + + +==== tests/cases/conformance/dynamicImport/foo.ts (0 errors) ==== + export default "./foo"; + +==== tests/cases/conformance/dynamicImport/index.ts (2 errors) ==== + async function foo() { + return await import((await import("./foo")).default); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + ~~~~~~~~~~~~~~~ +!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + } \ No newline at end of file diff --git a/tests/baselines/reference/importCallExpressionNestedES2015.js b/tests/baselines/reference/importCallExpressionNestedES2015.js new file mode 100644 index 00000000000..5c8a6a9edb5 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES2015.js @@ -0,0 +1,26 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedES2015.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +export default "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield import((yield import("./foo")).default); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedES2015.symbols b/tests/baselines/reference/importCallExpressionNestedES2015.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES2015.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedES2015.types b/tests/baselines/reference/importCallExpressionNestedES2015.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES2015.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedES20152.errors.txt b/tests/baselines/reference/importCallExpressionNestedES20152.errors.txt new file mode 100644 index 00000000000..1208dd0c709 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES20152.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/dynamicImport/index.ts(2,18): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. +tests/cases/conformance/dynamicImport/index.ts(2,32): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + + +==== tests/cases/conformance/dynamicImport/foo.ts (0 errors) ==== + export default "./foo"; + +==== tests/cases/conformance/dynamicImport/index.ts (2 errors) ==== + async function foo() { + return await import((await import("./foo")).default); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + ~~~~~~~~~~~~~~~ +!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules. + } \ No newline at end of file diff --git a/tests/baselines/reference/importCallExpressionNestedES20152.js b/tests/baselines/reference/importCallExpressionNestedES20152.js new file mode 100644 index 00000000000..2496f43f84f --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES20152.js @@ -0,0 +1,59 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedES20152.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +export default "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, import("./foo")]; + case 1: return [4 /*yield*/, import((_a.sent()).default)]; + case 2: return [2 /*return*/, _a.sent()]; + } + }); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedES20152.symbols b/tests/baselines/reference/importCallExpressionNestedES20152.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES20152.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedES20152.types b/tests/baselines/reference/importCallExpressionNestedES20152.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedES20152.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext.js b/tests/baselines/reference/importCallExpressionNestedESNext.js new file mode 100644 index 00000000000..8ec9b988201 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext.js @@ -0,0 +1,26 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +export default "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield import((yield import("./foo")).default); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext.symbols b/tests/baselines/reference/importCallExpressionNestedESNext.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext.types b/tests/baselines/reference/importCallExpressionNestedESNext.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext2.js b/tests/baselines/reference/importCallExpressionNestedESNext2.js new file mode 100644 index 00000000000..9a4d9f44f7a --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext2.js @@ -0,0 +1,59 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext2.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +export default "./foo"; +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, import("./foo")]; + case 1: return [4 /*yield*/, import((_a.sent()).default)]; + case 2: return [2 /*return*/, _a.sent()]; + } + }); + }); +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext2.symbols b/tests/baselines/reference/importCallExpressionNestedESNext2.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext2.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedESNext2.types b/tests/baselines/reference/importCallExpressionNestedESNext2.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedESNext2.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedSystem.js b/tests/baselines/reference/importCallExpressionNestedSystem.js new file mode 100644 index 00000000000..839a3601e38 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem.js @@ -0,0 +1,43 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + exports_1("default", "./foo"); + } + }; +}); +//// [index.js] +System.register([], function (exports_1, context_1) { + var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + var __moduleName = context_1 && context_1.id; + function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield context_1.import((yield context_1.import("./foo")).default); + }); + } + return { + setters: [], + execute: function () { + } + }; +}); diff --git a/tests/baselines/reference/importCallExpressionNestedSystem.symbols b/tests/baselines/reference/importCallExpressionNestedSystem.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedSystem.types b/tests/baselines/reference/importCallExpressionNestedSystem.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedSystem2.js b/tests/baselines/reference/importCallExpressionNestedSystem2.js new file mode 100644 index 00000000000..9b0fc20886d --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem2.js @@ -0,0 +1,76 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem2.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + exports_1("default", "./foo"); + } + }; +}); +//// [index.js] +System.register([], function (exports_1, context_1) { + var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } + }; + var __moduleName = context_1 && context_1.id; + function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, context_1.import("./foo")]; + case 1: return [4 /*yield*/, context_1.import((_a.sent()).default)]; + case 2: return [2 /*return*/, _a.sent()]; + } + }); + }); + } + return { + setters: [], + execute: function () { + } + }; +}); diff --git a/tests/baselines/reference/importCallExpressionNestedSystem2.symbols b/tests/baselines/reference/importCallExpressionNestedSystem2.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem2.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedSystem2.types b/tests/baselines/reference/importCallExpressionNestedSystem2.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedSystem2.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedUMD.js b/tests/baselines/reference/importCallExpressionNestedUMD.js new file mode 100644 index 00000000000..0b1d20af8a4 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD.js @@ -0,0 +1,51 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +(function (factory) { + if (typeof module === "object" && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = "./foo"; +}); +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +(function (factory) { + if (typeof module === "object" && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + "use strict"; + var __syncRequire = typeof module === "object" && typeof module.exports === "object"; + function foo() { + return __awaiter(this, void 0, void 0, function* () { + return yield _a = (yield __syncRequire ? Promise.resolve().then(() => require("./foo")) : new Promise((resolve_1, reject_1) => { require(["./foo"], resolve_1, reject_1); })).default, __syncRequire ? Promise.resolve().then(() => require(_a)) : new Promise((resolve_2, reject_2) => { require([_a], resolve_2, reject_2); }); + var _a; + }); + } +}); diff --git a/tests/baselines/reference/importCallExpressionNestedUMD.symbols b/tests/baselines/reference/importCallExpressionNestedUMD.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedUMD.types b/tests/baselines/reference/importCallExpressionNestedUMD.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/baselines/reference/importCallExpressionNestedUMD2.js b/tests/baselines/reference/importCallExpressionNestedUMD2.js new file mode 100644 index 00000000000..86fd0bfa8f1 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD2.js @@ -0,0 +1,84 @@ +//// [tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD2.ts] //// + +//// [foo.ts] +export default "./foo"; + +//// [index.ts] +async function foo() { + return await import((await import("./foo")).default); +} + +//// [foo.js] +(function (factory) { + if (typeof module === "object" && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = "./foo"; +}); +//// [index.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +(function (factory) { + if (typeof module === "object" && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + "use strict"; + var __syncRequire = typeof module === "object" && typeof module.exports === "object"; + function foo() { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, __syncRequire ? Promise.resolve().then(function () { return require("./foo"); }) : new Promise(function (resolve_1, reject_1) { require(["./foo"], resolve_1, reject_1); })]; + case 1: return [4 /*yield*/, (_b = (_a.sent()).default, __syncRequire ? Promise.resolve().then(function () { return require(_b); }) : new Promise(function (resolve_2, reject_2) { require([_b], resolve_2, reject_2); }))]; + case 2: return [2 /*return*/, _a.sent()]; + } + var _b; + }); + }); + } +}); diff --git a/tests/baselines/reference/importCallExpressionNestedUMD2.symbols b/tests/baselines/reference/importCallExpressionNestedUMD2.symbols new file mode 100644 index 00000000000..67e2eabd6fd --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD2.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : Symbol(foo, Decl(index.ts, 0, 0)) + + return await import((await import("./foo")).default); +>(await import("./foo")).default : Symbol(default, Decl(foo.ts, 0, 0)) +>"./foo" : Symbol("tests/cases/conformance/dynamicImport/foo", Decl(foo.ts, 0, 0)) +>default : Symbol(default, Decl(foo.ts, 0, 0)) +} diff --git a/tests/baselines/reference/importCallExpressionNestedUMD2.types b/tests/baselines/reference/importCallExpressionNestedUMD2.types new file mode 100644 index 00000000000..2f74d78b6c8 --- /dev/null +++ b/tests/baselines/reference/importCallExpressionNestedUMD2.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/dynamicImport/foo.ts === +export default "./foo"; +No type information for this code. +No type information for this code.=== tests/cases/conformance/dynamicImport/index.ts === +async function foo() { +>foo : () => Promise + + return await import((await import("./foo")).default); +>await import((await import("./foo")).default) : any +>import((await import("./foo")).default) : Promise +>(await import("./foo")).default : "./foo" +>(await import("./foo")) : typeof "tests/cases/conformance/dynamicImport/foo" +>await import("./foo") : typeof "tests/cases/conformance/dynamicImport/foo" +>import("./foo") : Promise +>"./foo" : "./foo" +>default : "./foo" +} diff --git a/tests/cases/compiler/asyncImportNestedYield.ts b/tests/cases/compiler/asyncImportNestedYield.ts new file mode 100644 index 00000000000..78b022e0797 --- /dev/null +++ b/tests/cases/compiler/asyncImportNestedYield.ts @@ -0,0 +1,4 @@ +// @lib: esnext +async function* foo() { + import((await import(yield "foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD.ts new file mode 100644 index 00000000000..1dbde4e1956 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD.ts @@ -0,0 +1,11 @@ +// @module: amd +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD2.ts new file mode 100644 index 00000000000..79540087a58 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedAMD2.ts @@ -0,0 +1,11 @@ +// @module: amd +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS.ts new file mode 100644 index 00000000000..5c99e56ecda --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS.ts @@ -0,0 +1,11 @@ +// @module: commonjs +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS2.ts new file mode 100644 index 00000000000..0776053d668 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedCJS2.ts @@ -0,0 +1,11 @@ +// @module: commonjs +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedES2015.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedES2015.ts new file mode 100644 index 00000000000..9708f466f5e --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedES2015.ts @@ -0,0 +1,11 @@ +// @module: es2015 +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedES20152.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedES20152.ts new file mode 100644 index 00000000000..c78b38db193 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedES20152.ts @@ -0,0 +1,11 @@ +// @module: es2015 +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext.ts new file mode 100644 index 00000000000..fffc12a7726 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext.ts @@ -0,0 +1,11 @@ +// @module: esnext +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext2.ts new file mode 100644 index 00000000000..246e9d931f0 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedESNext2.ts @@ -0,0 +1,11 @@ +// @module: esnext +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem.ts new file mode 100644 index 00000000000..04a11ac8169 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem.ts @@ -0,0 +1,11 @@ +// @module: system +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem2.ts new file mode 100644 index 00000000000..f8b2d4513ee --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedSystem2.ts @@ -0,0 +1,11 @@ +// @module: system +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD.ts new file mode 100644 index 00000000000..8b900a7dbd6 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD.ts @@ -0,0 +1,11 @@ +// @module: umd +// @target: es6 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD2.ts new file mode 100644 index 00000000000..e07dba0d2e5 --- /dev/null +++ b/tests/cases/conformance/dynamicImport/importCallExpressionNestedUMD2.ts @@ -0,0 +1,11 @@ +// @module: umd +// @target: es5 +// @skipLibCheck: true +// @lib: es6 +// @filename: foo.ts +export default "./foo"; + +// @filename: index.ts +async function foo() { + return await import((await import("./foo")).default); +} \ No newline at end of file From 6bfad5222522fbc614ba35b860f09c4736a535a4 Mon Sep 17 00:00:00 2001 From: Andrew Casey Date: Thu, 12 Oct 2017 13:23:08 -0700 Subject: [PATCH 13/13] Update missed baseline --- src/harness/unittests/tsserverProjectSystem.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 716c36d1e5d..7dce256e388 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -4412,9 +4412,9 @@ namespace ts.projectSystem { fileName: "/a.ts", textChanges: [ { - start: { line: 2, offset: 1 }, - end: { line: 3, offset: 1 }, - newText: " newFunction();\n", + start: { line: 2, offset: 3 }, + end: { line: 2, offset: 5 }, + newText: "newFunction();", }, { start: { line: 3, offset: 2 },