Add getEmitOutput and update call to getCurrentDirectory

src/compiler/core.ts

@@ -383,11 +383,12 @@ module ts {
         return [path.substr(0, rootLength)].concat(normalizedParts);
     }
 
-    export function getNormalizedPathComponents(path: string, currentDirectory: string) {
+    export function getNormalizedPathComponents(path: string, getCurrentDirectory: ()=>string) {
         var path = normalizeSlashes(path);
         var rootLength = getRootLength(path);
         if (rootLength == 0) {
             // If the path is not rooted it is relative to current directory
+            var currentDirectory = getCurrentDirectory();
             path = combinePaths(normalizeSlashes(currentDirectory), path);
             rootLength = getRootLength(path);
         }
@@ -443,18 +444,18 @@ module ts {
         }
     }
 
-    function getNormalizedPathOrUrlComponents(pathOrUrl: string, currentDirectory: string) {
+    function getNormalizedPathOrUrlComponents(pathOrUrl: string, getCurrentDirectory: ()=>string) {
         if (isUrl(pathOrUrl)) {
             return getNormalizedPathComponentsOfUrl(pathOrUrl);
         }
         else {
-            return getNormalizedPathComponents(pathOrUrl, currentDirectory);
+            return getNormalizedPathComponents(pathOrUrl, getCurrentDirectory);
         }
     }
 
-    export function getRelativePathToDirectoryOrUrl(directoryPathOrUrl: string, relativeOrAbsolutePath: string, currentDirectory: string, isAbsolutePathAnUrl: boolean) {
+    export function getRelativePathToDirectoryOrUrl(directoryPathOrUrl: string, relativeOrAbsolutePath: string, getCurrentDirectory: () => string, isAbsolutePathAnUrl: boolean) {
-        var pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
+        var pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, getCurrentDirectory);
-        var directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
+        var directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, getCurrentDirectory);
         if (directoryComponents.length > 1 && directoryComponents[directoryComponents.length - 1] === "") {
             // If the directory path given was of type test/cases/ then we really need components of directry to be only till its name 
             // that is  ["test", "cases", ""] needs to be actually ["test", "cases"]

src/compiler/emitter.ts

@@ -34,7 +34,7 @@ module ts {
         var newLine = program.getCompilerHost().getNewLine();
 
         function getSourceFilePathInNewDir(newDirPath: string, sourceFile: SourceFile) {
-            var sourceFilePath = getNormalizedPathFromPathCompoments(getNormalizedPathComponents(sourceFile.filename, compilerHost.getCurrentDirectory()));
+            var sourceFilePath = getNormalizedPathFromPathCompoments(getNormalizedPathComponents(sourceFile.filename, compilerHost.getCurrentDirectory));
             sourceFilePath = sourceFilePath.replace(program.getCommonSourceDirectory(), "");
             return combinePaths(newDirPath, sourceFilePath);
         }
@@ -523,7 +523,7 @@ module ts {
 
                     sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,
                         node.filename,
-                        compilerHost.getCurrentDirectory(),
+                        compilerHost.getCurrentDirectory,
                     /*isAbsolutePathAnUrl*/ true));
                     sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1;
 
@@ -640,7 +640,7 @@ module ts {
                         sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl(
                             getDirectoryPath(normalizePath(jsFilePath)), // get the relative sourceMapDir path based on jsFilePath
                             combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap
-                            compilerHost.getCurrentDirectory(),
+                            compilerHost.getCurrentDirectory,
                         /*isAbsolutePathAnUrl*/ true);
                     }
                     else {
@@ -3089,7 +3089,7 @@ module ts {
                 declFileName = getRelativePathToDirectoryOrUrl(
                     getDirectoryPath(normalizeSlashes(jsFilePath)),
                     declFileName,
-                    compilerHost.getCurrentDirectory(),
+                    compilerHost.getCurrentDirectory,
                 /*isAbsolutePathAnUrl*/ false);
 
                 referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;

src/compiler/parser.ts

@@ -3817,7 +3817,7 @@ module ts {
                     // Each file contributes into common source file path
                     if (!(sourceFile.flags & NodeFlags.DeclarationFile)
                         && !fileExtensionIs(sourceFile.filename, ".js")) {
-                        var sourcePathCompoments = getNormalizedPathComponents(sourceFile.filename, host.getCurrentDirectory());
+                        var sourcePathCompoments = getNormalizedPathComponents(sourceFile.filename, host.getCurrentDirectory);
                         sourcePathCompoments.pop(); // FileName is not part of directory
                         if (commonPathComponents) {
                             for (var i = 0; i < Math.min(commonPathComponents.length, sourcePathCompoments.length); i++) {

src/services/services.ts

@@ -2852,7 +2852,7 @@ module ts {
             var emitDeclaration = program.getCompilerOptions().declaration;
             var emitResult: EmitOutput = {
                 outputFiles: [],
-                emitOutputResult: null,
+                emitOutputResult: undefined,
             };
 
             // Initialize writter for CompilerHost.writeFile
@@ -2862,37 +2862,40 @@ module ts {
                     writeByteOrderMark: writeByteOrderMark,
                     text: data
                 }
-
                 emitResult.outputFiles.push(outputFile);
             }
 
-            // Get syntactic diagnostics
             var syntacticDiagnostics = emitToSingleFile
                 ? program.getDiagnostics(getSourceFile(filename).getSourceFile())
                 : program.getDiagnostics();
             program.getGlobalDiagnostics();
 
+            // If there is any syntactic error, terminate the process
             if (containErrors(syntacticDiagnostics)) {
                 emitResult.emitOutputResult = EmitOutputResult.FailedBecauseOfSyntaxErrors;
                 return emitResult;
             }
 
-            // Perform semantic and forace a type check before emit to ensure that all symbols are updated
+            // Perform semantic and force a type check before emit to ensure that all symbols are updated
             var semanticDiagnostics = emitToSingleFile
                 ? getFullTypeCheckChecker().getDiagnostics(getSourceFile(filename).getSourceFile())
                 : getFullTypeCheckChecker().getDiagnostics();
             getFullTypeCheckChecker().getGlobalDiagnostics();
-            getFullTypeCheckChecker().emitFiles();
+            var emitOutput = getFullTypeCheckChecker().emitFiles();
 
             if (emitDeclaration && containErrors(semanticDiagnostics)) {
                 emitResult.emitOutputResult = EmitOutputResult.FailedToGenerateDeclarationsBecauseOfSemanticErrors;
             }
+            else if (emitDeclaration && containErrors(emitOutput.errors)) {
+                emitResult.emitOutputResult = EmitOutputResult.FailedToGenerateDeclarationsBecauseOfSemanticErrors;
+            }
             else {
                 emitResult.emitOutputResult = EmitOutputResult.Succeeded;
             }
 
             // Reset writter back to underfined to make sure that we produce an error message if CompilerHost.writeFile method is called when we are not in an emitting stage
-            return null;
+            this.writter = undefined;
+            return emitResult;
         }
 
         /// Syntactic features