Restore fourslash tests

Author: Andy Hanson

src/harness/client.ts

@@ -73,7 +73,7 @@ namespace ts.server {
             return { span: this.decodeSpan(codeEdit, fileName), newText: codeEdit.newText };
         }
 
-        private processRequest<T extends protocol.Request>(command: string, args?: T["arguments"]): T {
+        private processRequest<T extends protocol.Request>(command: string, args: T["arguments"]): T {
             const request: protocol.Request = {
                 seq: this.sequence,
                 type: "request",
@@ -278,17 +278,18 @@ namespace ts.server {
 
             const request = this.processRequest<protocol.DefinitionRequest>(CommandNames.DefinitionAndBoundSpan, args);
             const response = this.processResponse<protocol.DefinitionInfoAndBoundSpanReponse>(request);
+            const body = Debug.assertDefined(response.body); // TODO: GH#18217
 
             return {
-                definitions: response.body!.definitions.map(entry => ({ // TODO: GH#18217
+                definitions: body.definitions.map(entry => ({
                     containerKind: ScriptElementKind.unknown,
                     containerName: "",
                     fileName: entry.file,
                     textSpan: this.decodeSpan(entry),
                     kind: ScriptElementKind.unknown,
                     name: ""
                 })),
-                textSpan: this.decodeSpan(response.body!.textSpan, request.arguments.file)
+                textSpan: this.decodeSpan(body.textSpan, request.arguments.file)
             };
         }
 
@@ -341,8 +342,10 @@ namespace ts.server {
             }));
         }
 
-        getEmitOutput(_fileName: string): EmitOutput {
-            return notImplemented();
+        getEmitOutput(file: string): EmitOutput {
+            const request = this.processRequest<protocol.EmitOutputRequest>(protocol.CommandTypes.EmitOutput, { file });
+            const response = this.processResponse<protocol.EmitOutputResponse>(request);
+            return response.body;
         }
 
         getSyntacticDiagnostics(file: string): DiagnosticWithLocation[] {

src/harness/fourslash.ts

@@ -1639,7 +1639,7 @@ Actual: ${stringify(fullActual)}`);
                 });
         }
 
-        public baselineGetEmitOutput(insertResultsIntoVfs?: boolean) {
+        private getEmitFiles(): ReadonlyArray<FourSlashFile> {
             // Find file to be emitted
             const emitFiles: FourSlashFile[] = [];  // List of FourSlashFile that has emitThisFile flag on
 
@@ -1656,12 +1656,31 @@ Actual: ${stringify(fullActual)}`);
                 this.raiseError("No emitThisFile is specified in the test file");
             }
 
+            return emitFiles;
+        }
+
+        public verifyGetEmitOutput(expectedOutputFiles: ReadonlyArray<string>): void {
+            const outputFiles = ts.flatMap(this.getEmitFiles(), e => this.languageService.getEmitOutput(e.fileName).outputFiles);
+
+            assert.deepEqual(outputFiles.map(f => f.name), expectedOutputFiles);
+
+            for (const { name, text } of outputFiles) {
+                const fromTestFile = this.getFileContent(name);
+                if (fromTestFile !== text) {
+                    this.raiseError("Emit output is not as expected: " + showTextDiff(fromTestFile, text));
+                }
+            }
+        }
+
+        public baselineGetEmitOutput(insertResultsIntoVfs?: boolean): void {
+            ts.Debug.assert(this.testType !== FourSlashTestType.Server, "Use verifyGetEmitOutput -- insertResultIntoVfs doesn't work with server");
+
             Harness.Baseline.runBaseline(
-                this.testData.globalOptions[MetadataOptionNames.baselineFile],
+                ts.Debug.assertDefined(this.testData.globalOptions[MetadataOptionNames.baselineFile]),
                 () => {
                     let resultString = "";
                     // Loop through all the emittedFiles and emit them one by one
-                    emitFiles.forEach(emitFile => {
+                    for (const emitFile of this.getEmitFiles()) {
                         const emitOutput = this.languageService.getEmitOutput(emitFile.fileName);
                         // Print emitOutputStatus in readable format
                         resultString += "EmitSkipped: " + emitOutput.emitSkipped + Harness.IO.newLine();
@@ -1687,13 +1706,13 @@ Actual: ${stringify(fullActual)}`);
 
                         for (const outputFile of emitOutput.outputFiles) {
                             const fileName = "FileName : " + outputFile.name + Harness.IO.newLine();
-                            resultString = resultString + fileName + outputFile.text;
+                            resultString = resultString + Harness.IO.newLine() + fileName + outputFile.text;
                             if (insertResultsIntoVfs) {
                                 this.languageServiceAdapterHost.addScript(ts.getNormalizedAbsolutePath(outputFile.name, "/"), outputFile.text, /*isRootFile*/ true);
                             }
                         }
                         resultString += Harness.IO.newLine();
-                    });
+                    }
 
                     return resultString;
                 });
@@ -3567,8 +3586,13 @@ ${code}
 
     function getNonFileNameOptionInObject(optionObject: { [s: string]: string }): string | undefined {
         for (const option in optionObject) {
-            if (option !== MetadataOptionNames.fileName) {
-                return option;
+            switch (option) {
+                case MetadataOptionNames.fileName:
+                case MetadataOptionNames.baselineFile:
+                case MetadataOptionNames.emitThisFile:
+                    break;
+                default:
+                    return option;
             }
         }
         return undefined;
@@ -4278,6 +4302,10 @@ namespace FourSlashInterface {
             this.state.baselineCurrentFileNameOrDottedNameSpans();
         }
 
+        public getEmitOutput(expectedOutputFiles: ReadonlyArray<string>): void {
+            this.state.verifyGetEmitOutput(expectedOutputFiles);
+        }
+
         public baselineGetEmitOutput(insertResultsIntoVfs?: boolean) {
             this.state.baselineGetEmitOutput(insertResultsIntoVfs);
         }

src/harness/harnessLanguageService.ts

@@ -707,7 +707,9 @@ namespace Harness.LanguageService {
             return ts.sys.getEnvironmentVariable(name);
         }
 
-        readDirectory() { return ts.notImplemented(); }
+        readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[] {
+            return this.host.readDirectory(path, extensions, exclude, include, depth);
+        }
 
         watchFile(): ts.FileWatcher {
             return { close: ts.noop };

src/server/protocol.ts

@@ -34,6 +34,8 @@ namespace ts.server.protocol {
         Implementation = "implementation",
         /* @internal */
         ImplementationFull = "implementation-full",
+        /* @internal */
+        EmitOutput = "emit-output",
         Exit = "exit",
         Format = "format",
         Formatonkey = "formatonkey",
@@ -802,6 +804,13 @@ namespace ts.server.protocol {
         readonly body: DefinitionInfoAndBoundSpan;
     }
 
+    /** @internal */
+    export interface EmitOutputRequest extends FileRequest {}
+    /** @internal */
+    export interface EmitOutputResponse extends Response {
+        readonly body: EmitOutput;
+    }
+
     /**
      * Go to type request; value of command field is
      * "typeDefinition". Return response giving the file locations that

src/server/session.ts

@@ -781,7 +781,7 @@ namespace ts.server {
         private getDefinitionAndBoundSpan(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.DefinitionInfoAndBoundSpan | DefinitionInfoAndBoundSpan {
             const { file, project } = this.getFileAndProject(args);
             const position = this.getPositionInFile(args, file);
-            const scriptInfo = project.getScriptInfo(file)!;
+            const scriptInfo = Debug.assertDefined(project.getScriptInfo(file));
 
             const unmappedDefinitionAndBoundSpan = project.getLanguageService().getDefinitionAndBoundSpan(file, position);
 
@@ -808,6 +808,11 @@ namespace ts.server {
             };
         }
 
+        private getEmitOutput(args: protocol.FileRequestArgs): EmitOutput {
+            const { file, project } = this.getFileAndProject(args);
+            return project.getLanguageService().getEmitOutput(file);
+        }
+
         private mapDefinitionInfo(definitions: ReadonlyArray<DefinitionInfo>, project: Project): ReadonlyArray<protocol.FileSpan> {
             return definitions.map(def => this.toFileSpan(def.fileName, def.textSpan, project));
         }
@@ -1998,6 +2003,9 @@ namespace ts.server {
             [CommandNames.DefinitionAndBoundSpanFull]: (request: protocol.DefinitionRequest) => {
                 return this.requiredResponse(this.getDefinitionAndBoundSpan(request.arguments, /*simplifiedResult*/ false));
             },
+            [CommandNames.EmitOutput]: (request: protocol.EmitOutputRequest) => {
+                return this.requiredResponse(this.getEmitOutput(request.arguments));
+            },
             [CommandNames.TypeDefinition]: (request: protocol.FileLocationRequest) => {
                 return this.requiredResponse(this.getTypeDefinition(request.arguments));
             },

src/services/sourcemaps.ts

@@ -1,7 +1,7 @@
 /* @internal */
 namespace ts {
     // Sometimes tools can sometimes see the following line as a source mapping url comment, so we mangle it a bit (the [M])
-    const sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)$/;
+    const sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\s*$/;
     const whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
     const base64UrlRegExp = /^data:(?:application\/json(?:;charset=[uU][tT][fF]-8);base64,([A-Za-z0-9+\/=]+)$)?/;
 
@@ -60,7 +60,7 @@ namespace ts {
             }, mapFileName, maps, getProgram(), sourcemappedFileCache);
         }
 
-        function getSourceMapper(fileName: string, file: { sourceMapper?: sourcemaps.SourceMapper }) {
+        function getSourceMapper(fileName: string, file: SourceFileLike): sourcemaps.SourceMapper {
             if (!host.readFile || !host.fileExists) {
                 return file.sourceMapper = sourcemaps.identitySourceMapper;
             }

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -10871,6 +10871,8 @@ declare namespace ts {
     function getParentNodeInSpan(node: Node | undefined, file: SourceFile, span: TextSpan): Node | undefined;
     function findModifier(node: Node, kind: Modifier["kind"]): Modifier | undefined;
     function insertImport(changes: textChanges.ChangeTracker, sourceFile: SourceFile, importDecl: Statement): void;
+    function textSpansEqual(a: TextSpan | undefined, b: TextSpan | undefined): boolean;
+    function documentSpansEqual(a: DocumentSpan, b: DocumentSpan): boolean;
 }
 declare namespace ts {
     function isFirstDeclarationOfSymbolParameter(symbol: Symbol): boolean;
@@ -12289,6 +12291,7 @@ declare namespace ts.server.protocol {
         DefinitionAndBoundSpanFull = "definitionAndBoundSpan-full",
         Implementation = "implementation",
         ImplementationFull = "implementation-full",
+        EmitOutput = "emit-output",
         Exit = "exit",
         Format = "format",
         Formatonkey = "formatonkey",
@@ -12617,6 +12620,11 @@ declare namespace ts.server.protocol {
     interface DefinitionAndBoundSpanResponse extends Response {
         readonly body: DefinitionInfoAndBoundSpan;
     }
+    interface EmitOutputRequest extends FileRequest {
+    }
+    interface EmitOutputResponse extends Response {
+        readonly body: EmitOutput;
+    }
     interface TypeDefinitionRequest extends FileLocationRequest {
         command: CommandTypes.TypeDefinition;
     }
@@ -14097,6 +14105,7 @@ declare namespace ts.server {
         private getDefinition;
         private mapDefinitionInfoLocations;
         private getDefinitionAndBoundSpan;
+        private getEmitOutput;
         private mapDefinitionInfo;
         private static mapToOriginalLocation;
         private toFileSpan;

tests/baselines/reference/getEmitOutputDeclarationMultiFiles.baseline

@@ -1,11 +1,13 @@
 EmitSkipped: false
+
 FileName : /tests/cases/fourslash/inputFile1.js
 var x = 5;
 var Bar = /** @class */ (function () {
     function Bar() {
     }
     return Bar;
 }());
+
 FileName : /tests/cases/fourslash/inputFile1.d.ts
 declare var x: number;
 declare class Bar {
@@ -14,13 +16,15 @@ declare class Bar {
 }
 
 EmitSkipped: false
+
 FileName : /tests/cases/fourslash/inputFile2.js
 var x1 = "hello world";
 var Foo = /** @class */ (function () {
     function Foo() {
     }
     return Foo;
 }());
+
 FileName : /tests/cases/fourslash/inputFile2.d.ts
 declare var x1: string;
 declare class Foo {

tests/baselines/reference/getEmitOutputDeclarationSingleFile.baseline

@@ -1,4 +1,5 @@
 EmitSkipped: false
+
 FileName : declSingleFile.js
 var x = 5;
 var Bar = /** @class */ (function () {
@@ -12,6 +13,7 @@ var Foo = /** @class */ (function () {
     }
     return Foo;
 }());
+
 FileName : declSingleFile.d.ts
 declare var x: number;
 declare class Bar {

tests/baselines/reference/getEmitOutputWithDeclarationFile.baseline

@@ -1,6 +1,7 @@
 EmitSkipped: false
 
 EmitSkipped: false
+
 FileName : /tests/cases/fourslash/inputFile2.js
 var x1 = "hello world";
 var Foo = /** @class */ (function () {