Enable project runner to compile generated .d.ts files

Uncovered bug in quoted .d.ts compilation

Author: sheetalkamat

src/harness/projectsRunner.ts

@@ -31,13 +31,15 @@ interface BatchCompileProjectTestCaseEmittedFile {
     fileName: string;
 }
 
-interface BatchCompileProjectTestCaseResult {
+interface CompileProjectFilesResult {
     moduleKind: ts.ModuleKind;
     program: ts.Program;
-    readInputFiles: ts.SourceFile[];
+    errors: ts.Diagnostic[];
     sourceMapData: ts.SourceMapData[];
+}
+
+interface BatchCompileProjectTestCaseResult extends CompileProjectFilesResult {
     outputFiles: BatchCompileProjectTestCaseEmittedFile[];
-    errors: ts.Diagnostic[];
     nonSubfolderDiskFiles: number;
 }
 
@@ -116,13 +118,43 @@ class ProjectRunner extends RunnerBase {
 
             return url;
         }
-       
-        function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult{
-            var nonSubfolderDiskFiles = 0;
 
-            var readInputFiles: ts.SourceFile[] = [];
+        function getCurrentDirectory() {
+            return sys.resolvePath(testCase.projectRoot);
+        }
+
+        function compileProjectFiles(moduleKind: ts.ModuleKind, getInputFiles: ()=> string[],
+            getSourceFileText: (filename: string) => string,
+            writeFile: (filename: string, data: string) => void): CompileProjectFilesResult {
+
+            var program = ts.createProgram(getInputFiles(), createCompilerOptions(), createCompilerHost());
+            var errors = program.getDiagnostics();
             var sourceMapData: ts.SourceMapData[] = null;
-            var outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
+            if (!errors.length) {
+                var checker = program.getTypeChecker();
+                errors = checker.getDiagnostics();
+                var emitResult = checker.emitFiles();
+                errors = ts.concatenate(errors, emitResult.errors);
+                sourceMapData = emitResult.sourceMaps;
+
+                // Clean up source map data that will be used in baselining
+                if (sourceMapData) {
+                    for (var i = 0; i < sourceMapData.length; i++) {
+                        for (var j = 0; j < sourceMapData[i].sourceMapSources.length; j++) {
+                            sourceMapData[i].sourceMapSources[j] = cleanProjectUrl(sourceMapData[i].sourceMapSources[j]);
+                        }
+                        sourceMapData[i].jsSourceMappingURL = cleanProjectUrl(sourceMapData[i].jsSourceMappingURL);
+                        sourceMapData[i].sourceMapSourceRoot = cleanProjectUrl(sourceMapData[i].sourceMapSourceRoot);
+                    }
+                }
+            }
+
+            return {
+                moduleKind: moduleKind,
+                program: program,
+                errors: errors,
+                sourceMapData: sourceMapData
+            };
 
             function createCompilerOptions(): ts.CompilerOptions {
                 return {
@@ -142,28 +174,55 @@ class ProjectRunner extends RunnerBase {
                     sourceFile = ts.createSourceFile('lib.d.ts', Harness.Compiler.libTextMinimal, languageVersion, ts.ByteOrderMark.None);
                 }
                 else {
-                    assert.isTrue(!ts.filter(readInputFiles, sourceFile => sourceFile.filename == filename).length, "Compiler trying to read same file again: " + filename);
-
-                    try {
-                        var text = sys.readFile(ts.isRootedDiskPath(filename)
-                            ? filename
-                            : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(filename));
-                    }
-                    catch (e) {
-                        // text doesn't get defined.
-                    }
-
+                    var text = getSourceFileText(filename);
                     if (text !== undefined) {
                         sourceFile = ts.createSourceFile(filename, text, languageVersion, ts.ByteOrderMark.None);
                     }
                 }
 
-                if (sourceFile) {
-                    readInputFiles.push(sourceFile);
-                }
                 return sourceFile;
             }
 
+            function createCompilerHost(): ts.CompilerHost {
+                return {
+                    getSourceFile: getSourceFile,
+                    getDefaultLibFilename: () => "lib.d.ts",
+                    writeFile: writeFile,
+                    getCurrentDirectory: getCurrentDirectory,
+                    getCanonicalFileName: ts.getCanonicalFileName,
+                    useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
+                    getNewLine: () => sys.newLine
+                };
+            }
+        }
+       
+        function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult{
+            var nonSubfolderDiskFiles = 0;
+
+            var outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
+
+            var projectCompilerResult = compileProjectFiles(moduleKind, () => testCase.inputFiles, getSourceFileText, writeFile);
+            return {
+                moduleKind: moduleKind,
+                program: projectCompilerResult.program,
+                sourceMapData: projectCompilerResult.sourceMapData,
+                outputFiles: outputFiles,
+                errors: projectCompilerResult.errors,
+                nonSubfolderDiskFiles: nonSubfolderDiskFiles,
+            };
+
+            function getSourceFileText(filename: string): string {
+                try {
+                    var text = sys.readFile(ts.isRootedDiskPath(filename)
+                        ? filename
+                        : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(filename));
+                }
+                catch (e) {
+                    // text doesn't get defined.
+                }
+                return text;
+            }
+
             function writeFile(filename: string, data: string) {
                 var diskFileName = ts.isRootedDiskPath(filename)
                     ? filename
@@ -211,53 +270,47 @@ class ProjectRunner extends RunnerBase {
 
                 outputFiles.push({ emittedFileName: filename, code: data, fileName: diskRelativeName });
             }
+        }
 
-            function getCurrentDirectory() {
-                return sys.resolvePath(testCase.projectRoot);
-            }
+        function compileCompileDTsFiles(compilerResult: BatchCompileProjectTestCaseResult) {
+            var inputDtsSourceFiles = ts.map(ts.filter(compilerResult.program.getSourceFiles(),
+                sourceFile => Harness.Compiler.isDTS(sourceFile.filename)),
+                sourceFile => {
+                    return { emittedFileName: sourceFile.filename, code: sourceFile.text };
+                });
 
-            function createCompilerHost(): ts.CompilerHost {
-                return {
-                    getSourceFile: getSourceFile,
-                    getDefaultLibFilename: () => "lib.d.ts",
-                    writeFile: writeFile,
-                    getCurrentDirectory: getCurrentDirectory,
-                    getCanonicalFileName: ts.getCanonicalFileName,
-                    useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
-                    getNewLine:()=> sys.newLine
-                };
+            var ouputDtsFiles = ts.filter(compilerResult.outputFiles, ouputFile => Harness.Compiler.isDTS(ouputFile.emittedFileName));
+            var allInputFiles = inputDtsSourceFiles.concat(ouputDtsFiles);
+            return compileProjectFiles(compilerResult.moduleKind,getInputFiles, getSourceFileText, writeFile);
+
+            function getInputFiles() {
+                return ts.map(allInputFiles, outputFile => outputFile.emittedFileName);
+            }
+            function getSourceFileText(filename: string): string {
+                return ts.forEach(allInputFiles, inputFile => inputFile.emittedFileName === filename ? inputFile.code : undefined);
             }
 
-            var program = ts.createProgram(testCase.inputFiles, createCompilerOptions(), createCompilerHost());
-            var errors = program.getDiagnostics();
-            if (!errors.length) {
-                var checker = program.getTypeChecker();
-                errors = checker.getDiagnostics();
-                var emitResult = checker.emitFiles();
-                errors = ts.concatenate(errors, emitResult.errors);
-                sourceMapData = emitResult.sourceMaps;
+            function writeFile(filename: string, data: string) {
+            }
+        }
 
-                // Clean up source map data that will be used in baselining
-                if (sourceMapData) {
-                    for (var i = 0; i < sourceMapData.length; i++) {
-                        for (var j = 0; j < sourceMapData[i].sourceMapSources.length; j++) {
-                            sourceMapData[i].sourceMapSources[j] = cleanProjectUrl(sourceMapData[i].sourceMapSources[j]);
-                        }
-                        sourceMapData[i].jsSourceMappingURL = cleanProjectUrl(sourceMapData[i].jsSourceMappingURL);
-                        sourceMapData[i].sourceMapSourceRoot = cleanProjectUrl(sourceMapData[i].sourceMapSourceRoot);
-                    }
+        function getErrorsBaseline(compilerResult: CompileProjectFilesResult) {
+            // This is copied from tc.ts's reportError to replicate what tc does
+            var errors = "";
+            for (var i = 0; i < compilerResult.errors.length; i++) {
+                var error = compilerResult.errors[i];
+                // TODO(jfreeman): Remove assert
+                ts.Debug.assert(error.messageText.indexOf("{NL}") < 0);
+                if (error.file) {
+                    var loc = error.file.getLineAndCharacterFromPosition(error.start);
+                    errors += error.file.filename + "(" + loc.line + "," + loc.character + "): " + error.messageText + sys.newLine;
+                }
+                else {
+                    errors += error.messageText + sys.newLine;
                 }
             }
 
-            return {
-                moduleKind: moduleKind,                
-                program: program,
-                readInputFiles: readInputFiles,
-                sourceMapData: sourceMapData,
-                outputFiles: outputFiles,
-                errors: errors,
-                nonSubfolderDiskFiles: nonSubfolderDiskFiles,
-            };
+            return errors;
         }
 
         describe('Compiling project for ' + testCase.scenario +': testcase ' + testCaseFileName, () => {
@@ -278,15 +331,14 @@ class ProjectRunner extends RunnerBase {
                         baselineCheck: testCase.baselineCheck,
                         runTest: testCase.runTest,
                         bug: testCase.bug,
-                        resolvedInputFiles: ts.map(compilerResult.readInputFiles, inputFile => inputFile.filename),
+                        resolvedInputFiles: ts.map(compilerResult.program.getSourceFiles(), inputFile => inputFile.filename),
                         emittedFiles: ts.map(compilerResult.outputFiles, outputFile => outputFile.emittedFileName)
                     };
 
                     return resolutionInfo;
                 }
 
                 it('Resolution information of (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, () => {
-                    assert.equal(compilerResult.program.getSourceFiles().length, compilerResult.readInputFiles.length, "Compiler missing/has extra source files that were read during compilation");
                     Harness.Baseline.runBaseline('Resolution information of (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + '.json', () => {
                         return JSON.stringify(getCompilerResolutionInfo(), undefined, "    ");
                     });
@@ -295,22 +347,7 @@ class ProjectRunner extends RunnerBase {
                 if (compilerResult.errors.length) {
                     it('Errors for (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, () => {
                         Harness.Baseline.runBaseline('Errors for (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + '.errors.txt', () => {
-                            // This is copied from tc.ts's reportError to replicate what tc does
-                            var errors = "";
-                            for (var i = 0; i < compilerResult.errors.length; i++) {
-                                var error = compilerResult.errors[i];
-                                // TODO(jfreeman): Remove assert
-                                ts.Debug.assert(error.messageText.indexOf("{NL}") < 0);
-                                if (error.file) {
-                                    var loc = error.file.getLineAndCharacterFromPosition(error.start);
-                                    errors += error.file.filename + "(" + loc.line + "," + loc.character + "): " + error.messageText + sys.newLine;
-                                }
-                                else {
-                                    errors += error.messageText + sys.newLine;
-                                }
-                            }
-
-                            return errors;
+                            return getErrorsBaseline(compilerResult);
                         });
                     });
                 }
@@ -337,6 +374,18 @@ class ProjectRunner extends RunnerBase {
                             });
                         });
                     }
+
+                    // Verify that all the generated .d.ts files compile
+                    if (!compilerResult.errors.length && testCase.declaration) {
+                        var dTsCompileResult = compileCompileDTsFiles(compilerResult);
+                        if (dTsCompileResult.errors.length) {
+                            it('Errors in generated Dts files for (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, () => {
+                                Harness.Baseline.runBaseline('Errors in generated Dts files for (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + '.dts.errors.txt', () => {
+                                    return getErrorsBaseline(dTsCompileResult);
+                                });
+                            });
+                        }
+                    }
                 }
             }
 

tests/baselines/reference/project/baseline/amd/baseline.json

@@ -7,9 +7,9 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "emit.ts",
+        "lib.d.ts",
         "decl.ts",
-        "lib.d.ts"
+        "emit.ts"
     ],
     "emittedFiles": [
         "decl.js",

tests/baselines/reference/project/baseline/node/baseline.json

@@ -7,9 +7,9 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "emit.ts",
+        "lib.d.ts",
         "decl.ts",
-        "lib.d.ts"
+        "emit.ts"
     ],
     "emittedFiles": [
         "decl.js",

tests/baselines/reference/project/baseline2/amd/baseline2.json

@@ -7,9 +7,9 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "dont_emit.ts",
+        "lib.d.ts",
         "decl.ts",
-        "lib.d.ts"
+        "dont_emit.ts"
     ],
     "emittedFiles": [
         "decl.js",

tests/baselines/reference/project/baseline2/node/baseline2.json

@@ -7,9 +7,9 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "dont_emit.ts",
+        "lib.d.ts",
         "decl.ts",
-        "lib.d.ts"
+        "dont_emit.ts"
     ],
     "emittedFiles": [
         "decl.js",

tests/baselines/reference/project/baseline3/amd/baseline3.json

@@ -7,8 +7,8 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "nestedModule.ts",
-        "lib.d.ts"
+        "lib.d.ts",
+        "nestedModule.ts"
     ],
     "emittedFiles": [
         "nestedModule.js"

tests/baselines/reference/project/baseline3/node/baseline3.json

@@ -7,8 +7,8 @@
     "baselineCheck": true,
     "runTest": true,
     "resolvedInputFiles": [
-        "nestedModule.ts",
-        "lib.d.ts"
+        "lib.d.ts",
+        "nestedModule.ts"
     ],
     "emittedFiles": [
         "nestedModule.js"

tests/baselines/reference/project/cantFindTheModule/amd/cantFindTheModule.json

@@ -5,8 +5,8 @@
         "decl.ts"
     ],
     "resolvedInputFiles": [
-        "decl.ts",
-        "lib.d.ts"
+        "lib.d.ts",
+        "decl.ts"
     ],
     "emittedFiles": [
         "decl.js"

tests/baselines/reference/project/cantFindTheModule/node/cantFindTheModule.json

@@ -5,8 +5,8 @@
         "decl.ts"
     ],
     "resolvedInputFiles": [
-        "decl.ts",
-        "lib.d.ts"
+        "lib.d.ts",
+        "decl.ts"
     ],
     "emittedFiles": [
         "decl.js"

tests/baselines/reference/project/circularReferencing/amd/circularReferencing.json

@@ -5,9 +5,9 @@
         "consume.ts"
     ],
     "resolvedInputFiles": [
-        "consume.ts",
+        "lib.d.ts",
         "decl.ts",
-        "lib.d.ts"
+        "consume.ts"
     ],
     "emittedFiles": [
         "decl.js",