Deprecate CompilerResult

Author: rbuckton

src/harness/compiler.ts

@@ -227,14 +227,22 @@ namespace compiler {
         public readonly program: ts.Program | undefined;
         public readonly result: ts.EmitResult | undefined;
         public readonly options: ts.CompilerOptions;
-        public readonly diagnostics: ts.Diagnostic[];
-        public readonly js: core.KeyedCollection<string, documents.TextDocument>;
-        public readonly dts: core.KeyedCollection<string, documents.TextDocument>;
-        public readonly maps: core.KeyedCollection<string, documents.TextDocument>;
+        public readonly diagnostics: ReadonlyArray<ts.Diagnostic>;
+        public readonly js: core.ReadonlyKeyedCollection<string, documents.TextDocument>;
+        public readonly dts: core.ReadonlyKeyedCollection<string, documents.TextDocument>;
+        public readonly maps: core.ReadonlyKeyedCollection<string, documents.TextDocument>;
 
         private _inputs: documents.TextDocument[] = [];
         private _inputsAndOutputs: core.KeyedCollection<string, CompilationOutput>;
 
+        // from CompilerResult
+        public readonly files: ReadonlyArray<Harness.Compiler.GeneratedFile>;
+        public readonly declFilesCode: ReadonlyArray<Harness.Compiler.GeneratedFile>;
+        public readonly sourceMaps: ReadonlyArray<Harness.Compiler.GeneratedFile>;
+        public readonly errors: ReadonlyArray<ts.Diagnostic>;
+        public readonly currentDirectoryForProgram: string;
+        public readonly traceResults: ReadonlyArray<string>;
+
         constructor(host: CompilerHost, options: ts.CompilerOptions, program: ts.Program | undefined, result: ts.EmitResult | undefined, diagnostics: ts.Diagnostic[]) {
             this.host = host;
             this.program = program;
@@ -243,18 +251,18 @@ namespace compiler {
             this.options = program ? program.getCompilerOptions() : options;
 
             // collect outputs
-            this.js = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
-            this.dts = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
-            this.maps = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
+            const js = this.js = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
+            const dts = this.dts = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
+            const maps = this.maps = new core.KeyedCollection<string, documents.TextDocument>(this.vfs.pathComparer);
             for (const document of this.host.outputs) {
                 if (vpath.isJavaScript(document.file)) {
-                    this.js.set(document.file, document);
+                    js.set(document.file, document);
                 }
                 else if (vpath.isDeclaration(document.file)) {
-                    this.dts.set(document.file, document);
+                    dts.set(document.file, document);
                 }
                 else if (vpath.isSourceMap(document.file)) {
-                    this.maps.set(document.file, document);
+                    maps.set(document.file, document);
                 }
             }
 
@@ -268,9 +276,9 @@ namespace compiler {
                         if (!vpath.isDeclaration(sourceFile.fileName)) {
                             const outputs = {
                                 input,
-                                js: this.js.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options))),
-                                dts: this.dts.get(this.getOutputPath(sourceFile.fileName, ".d.ts", this.options.declarationDir)),
-                                map: this.maps.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options) + ".map"))
+                                js: js.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options))),
+                                dts: dts.get(this.getOutputPath(sourceFile.fileName, ".d.ts", this.options.declarationDir)),
+                                map: maps.get(this.getOutputPath(sourceFile.fileName, ts.getOutputExtension(sourceFile, this.options) + ".map"))
                             };
 
                             this._inputsAndOutputs.set(sourceFile.fileName, outputs);
@@ -281,9 +289,17 @@ namespace compiler {
                     }
                 }
             }
+
+            // from CompilerResult
+            this.files = Array.from(this.js.values(), file => file.asGeneratedFile());
+            this.declFilesCode = Array.from(this.dts.values(), file => file.asGeneratedFile());
+            this.sourceMaps = Array.from(this.maps.values(), file => file.asGeneratedFile());
+            this.errors = diagnostics;
+            this.currentDirectoryForProgram = host.vfs.currentDirectory;
+            this.traceResults = host.traces;
         }
 
-        public get vfs() {
+        public get vfs(): vfs.VirtualFileSystem {
             return this.host.vfs;
         }
 
@@ -326,6 +342,12 @@ namespace compiler {
             return outputs && outputs[kind];
         }
 
+        public getSourceMapRecord(): string | undefined {
+            if (this.result.sourceMaps && this.result.sourceMaps.length > 0) {
+                return Harness.SourceMapRecorder.getSourceMapRecord(this.result.sourceMaps, this.program, this.files);
+            }
+        }
+
         public getSourceMap(path: string): documents.SourceMap | undefined {
             if (this.options.noEmit || vpath.isDeclaration(path)) return undefined;
             if (this.options.inlineSourceMap) {
@@ -338,7 +360,7 @@ namespace compiler {
             }
         }
 
-        public getOutputPath(path: string, ext: string, outDir: string | undefined = this.options.outDir) {
+        public getOutputPath(path: string, ext: string, outDir: string | undefined = this.options.outDir): string {
             if (outDir) {
                 path = vpath.resolve(this.vfs.currentDirectory, path);
                 const common = this.commonSourceDirectory;
@@ -352,8 +374,7 @@ namespace compiler {
         }
     }
 
-    export function compileFiles(host: CompilerHost, rootFiles: string[] | undefined, compilerOptions: ts.CompilerOptions) {
-        // establish defaults (aligns with old harness)
+    export function compileFiles(host: CompilerHost, rootFiles: string[] | undefined, compilerOptions: ts.CompilerOptions): CompilationResult {
         if (compilerOptions.project || !rootFiles || rootFiles.length === 0) {
             const project = readProject(host.parseConfigHost, compilerOptions.project, compilerOptions);
             if (project) {
@@ -368,6 +389,7 @@ namespace compiler {
             delete compilerOptions.project;
         }
 
+        // establish defaults (aligns with old harness)
         if (compilerOptions.target === undefined) compilerOptions.target = ts.ScriptTarget.ES3;
         if (compilerOptions.newLine === undefined) compilerOptions.newLine = ts.NewLineKind.CarriageReturnLineFeed;
         if (compilerOptions.skipDefaultLibCheck === undefined) compilerOptions.skipDefaultLibCheck = true;

src/harness/compilerRunner.ts

@@ -108,7 +108,7 @@ class CompilerTest {
     private lastUnit: Harness.TestCaseParser.TestUnitData;
     private harnessSettings: Harness.TestCaseParser.CompilerSettings;
     private hasNonDtsFiles: boolean;
-    private result: Harness.Compiler.CompilerResult;
+    private result: compiler.CompilationResult;
     private options: ts.CompilerOptions;
     private tsConfigFiles: Harness.Compiler.TestFile[];
     // equivalent to the files that will be passed on the command line

src/harness/core.ts

@@ -1,5 +1,3 @@
-/// <reference path="./harness.ts" />
-
 // NOTE: The contents of this file are all exported from the namespace 'core'. This is to
 //       support the eventual conversion of harness into a modular system.
 
@@ -63,10 +61,20 @@ namespace core {
     // Collections
     //
 
+    export interface ReadonlyKeyedCollection<K, V> {
+        readonly size: number;
+        has(key: K): boolean;
+        get(key: K): V | undefined;
+        forEach(callback: (value: V, key: K, collection: this) => void): void;
+        keys(): IterableIterator<K>;
+        values(): IterableIterator<V>;
+        entries(): IterableIterator<[K, V]>;
+    }
+
     /**
      * A collection of key/value pairs internally sorted by key.
      */
-    export class KeyedCollection<K, V> {
+    export class KeyedCollection<K, V> implements ReadonlyKeyedCollection<K, V> {
         private _comparer: (a: K, b: K) => number;
         private _keys: K[] = [];
         private _values: V[] = [];
@@ -101,7 +109,7 @@ namespace core {
                 insertAt(this._keys, ~index, key);
                 insertAt(this._values, ~index, value);
                 insertAt(this._order, ~index, this._version);
-                this._version++;
+                this.writePostScript();
             }
             return this;
         }
@@ -113,7 +121,7 @@ namespace core {
                 removeAt(this._keys, index);
                 removeAt(this._values, index);
                 removeAt(this._order, index);
-                this._version++;
+                this.writePostScript();
                 return true;
             }
             return false;
@@ -125,7 +133,7 @@ namespace core {
                 this._keys.length = 0;
                 this._values.length = 0;
                 this._order.length = 0;
-                this._version = 0;
+                this.writePostScript();
             }
         }
 
@@ -143,6 +151,46 @@ namespace core {
             }
         }
 
+        public * keys() {
+            const keys = this._keys;
+            const order = this.getInsertionOrder();
+            const version = this._version;
+            this._copyOnWrite = true;
+            for (const index of order) {
+                yield keys[index];
+            }
+            if (version === this._version) {
+                this._copyOnWrite = false;
+            }
+        }
+
+        public * values() {
+            const values = this._values;
+            const order = this.getInsertionOrder();
+            const version = this._version;
+            this._copyOnWrite = true;
+            for (const index of order) {
+                yield values[index];
+            }
+            if (version === this._version) {
+                this._copyOnWrite = false;
+            }
+        }
+
+        public * entries() {
+            const keys = this._keys;
+            const values = this._values;
+            const order = this.getInsertionOrder();
+            const version = this._version;
+            this._copyOnWrite = true;
+            for (const index of order) {
+                yield [keys[index], values[index]] as [K, V];
+            }
+            if (version === this._version) {
+                this._copyOnWrite = false;
+            }
+        }
+
         private writePreamble() {
             if (this._copyOnWrite) {
                 this._keys = this._keys.slice();
@@ -152,10 +200,14 @@ namespace core {
             }
         }
 
+        private writePostScript() {
+            this._version++;
+        }
+
         private getInsertionOrder() {
             return this._order
                 .map((_, i) => i)
-                .sort((x, y) => compareNumbers(this._order[x], this._order[y]));
+                .sort((x, y) => this._order[x] - this._order[y]);
         }
     }
 
@@ -325,6 +377,10 @@ namespace core {
         return length ? text.slice(length) : text;
     }
 
+    export function addUTF8ByteOrderMark(text: string) {
+        return getByteOrderMarkLength(text) === 0 ? "\u00EF\u00BB\u00BF" + text : text;
+    }
+
     function splitLinesWorker(text: string, lineStarts: number[] | undefined, lines: string[] | undefined, removeEmptyElements: boolean) {
         let pos = 0;
         let end = 0;

src/harness/documents.ts

@@ -10,6 +10,8 @@ namespace documents {
         public readonly text: string;
 
         private _lineStarts: core.LineStarts | undefined;
+        private _testFile: Harness.Compiler.TestFile | undefined;
+        private _generatedFile: Harness.Compiler.GeneratedFile | undefined;
 
         constructor(file: string, text: string, meta?: Map<string, string>) {
             this.file = file;
@@ -20,6 +22,37 @@ namespace documents {
         public get lineStarts(): core.LineStarts {
             return this._lineStarts || (this._lineStarts = core.computeLineStarts(this.text));
         }
+
+        public static fromTestFile(file: Harness.Compiler.TestFile) {
+            return new TextDocument(
+                file.unitName,
+                file.content,
+                file.fileOptions && Object.keys(file.fileOptions)
+                    .reduce((meta, key) => meta.set(key, file.fileOptions[key]), new Map<string, string>()));
+        }
+
+        public asTestFile() {
+            return this._testFile || (this._testFile = {
+                unitName: this.file,
+                content: this.text,
+                fileOptions: Array.from(this.meta)
+                    .reduce((obj, [key, value]) => (obj[key] = value, obj), {} as Record<string, string>)
+            });
+        }
+
+        public static fromGeneratedFile(file: Harness.Compiler.GeneratedFile) {
+            return new TextDocument(
+                file.fileName,
+                file.writeByteOrderMark ? core.addUTF8ByteOrderMark(file.code) : file.code);
+        }
+
+        public asGeneratedFile() {
+            return this._generatedFile || (this._generatedFile = {
+                fileName: this.file,
+                code: core.removeByteOrderMark(this.text),
+                writeByteOrderMark: core.getByteOrderMarkLength(this.text) > 0
+            });
+        }
     }
 
     export interface RawSourceMap {