Fix getEmitOutput to only output one file except when 'out' flag is specified. Add testcases

Author: Yui T

src/compiler/checker.ts

@@ -7183,15 +7183,7 @@ module ts {
 
         function hasSemanticErrors() {
             // Return true if there is any semantic error in a file or globally
-            return (getDiagnostics().length > 0) || (getGlobalDiagnostics().length > 0);
-        }
-
-        function shouldEmitDeclarations() {
-            // If the declaration emit and there are no errors being reported in program or by checker
-            // declarations can be emitted
-            return compilerOptions.declaration &&
-                !program.getDiagnostics().length &&
-                !getDiagnostics().length;
+            return getDiagnostics().length > 0 || getGlobalDiagnostics().length > 0;
         }
 
         function isReferencedImportDeclaration(node: ImportDeclaration): boolean {
@@ -7252,7 +7244,7 @@ module ts {
             writeTypeToTextWriter(getReturnTypeOfSignature(signature), enclosingDeclaration, flags , writer);
         }
 
-        function invokeEmitter() {
+        function invokeEmitter(targetSourceFile?: SourceFile) {
             var resolver: EmitResolver = {
                 getProgram: () => program,
                 getLocalNameOfContainer: getLocalNameOfContainer,
@@ -7264,7 +7256,6 @@ module ts {
                 getEnumMemberValue: getEnumMemberValue,
                 isTopLevelValueImportedViaEntityName: isTopLevelValueImportedViaEntityName,
                 hasSemanticErrors: hasSemanticErrors,
-                shouldEmitDeclarations: shouldEmitDeclarations,
                 isDeclarationVisible: isDeclarationVisible,
                 isImplementationOfOverload: isImplementationOfOverload,
                 writeTypeAtLocation: writeTypeAtLocation,
@@ -7274,7 +7265,7 @@ module ts {
                 isImportDeclarationEntityNameReferenceDeclarationVisibile: isImportDeclarationEntityNameReferenceDeclarationVisibile
             };
             checkProgram();
-            return emitFiles(resolver);
+            return emitFiles(resolver, targetSourceFile);
         }
 
         function initializeTypeChecker() {

src/compiler/emitter.ts

@@ -25,15 +25,21 @@ module ts {
         return indentStrings[1].length;
     }
 
-    export function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
+    export function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions): boolean {
         if (!(sourceFile.flags & NodeFlags.DeclarationFile)) {
             if ((isExternalModule(sourceFile) || !compilerOptions.out) && !fileExtensionIs(sourceFile.filename, ".js")) {
                 return true;
             }
+            return false;
         }
+        return false;
+    }
+    export function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {
+        return isExternalModule(sourceFile) || (sourceFile.flags & NodeFlags.DeclarationFile) !== 0;
     }
 
-    export function emitFiles(resolver: EmitResolver): EmitResult {
+    // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compilerOnSave feature
+    export function emitFiles(resolver: EmitResolver, targetSourceFile?: SourceFile): EmitResult {
         var program = resolver.getProgram();
         var compilerHost = program.getCompilerHost();
         var compilerOptions = program.getCompilerOptions();
@@ -58,10 +64,6 @@ module ts {
             return emitOutputFilePathWithoutExtension + extension;
         }
 
-        function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {
-            return isExternalModule(sourceFile) || (sourceFile.flags & NodeFlags.DeclarationFile) !== 0;
-        }
-
         function getFirstConstructorWithBody(node: ClassDeclaration): ConstructorDeclaration {
             return forEach(node.members, member => {
                 if (member.kind === SyntaxKind.Constructor && (<ConstructorDeclaration>member).body) {
@@ -3161,44 +3163,50 @@ module ts {
             }
         }
 
-        var shouldEmitDeclarations = resolver.shouldEmitDeclarations();
+        var hasSemanticErros = resolver.hasSemanticErrors();
+        var returnCode = EmitReturnStatus.Succeeded;
+
         function emitFile(jsFilePath: string, sourceFile?: SourceFile) {
             emitJavaScript(jsFilePath, sourceFile);
-            if (shouldEmitDeclarations) {
+            // Update the returnCode with appropriate value depended on whether we have semantic errors 
+            if (!hasSemanticErros && compilerOptions.declaration) {
+                returnCode = EmitReturnStatus.Succeeded;
                 emitDeclarations(jsFilePath, sourceFile);
             }
+            else if (hasSemanticErros && compilerOptions.declaration) {
+                returnCode = EmitReturnStatus.DeclarationGenerationSkipped;
+            }
+            else if (hasSemanticErros && !compilerOptions.declaration) {
+                returnCode = EmitReturnStatus.JSGeneratedWithSemanticErrors;
+            }
+        }
+
+        if (targetSourceFile === undefined) {
+            forEach(program.getSourceFiles(), sourceFile => {
+                if (shouldEmitToOwnFile(sourceFile, compilerOptions)) {
+                    var jsFilePath = getOwnEmitOutputFilePath(sourceFile, ".js");
+                    emitFile(jsFilePath, sourceFile);
+                }
+            });
+        }
+        else {
+            // Emit only one file specified in targetFilename. This is mainly used in compilerOnSave feature
+            var jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, ".js");
+            emitFile(jsFilePath, targetSourceFile);
         }
 
-        forEach(program.getSourceFiles(), sourceFile => {
-            if (shouldEmitToOwnFile(sourceFile, compilerOptions)) {
-                var jsFilePath = getOwnEmitOutputFilePath(sourceFile, ".js");
-                emitFile(jsFilePath, sourceFile);
-            }
-        });
         if (compilerOptions.out) {
             emitFile(compilerOptions.out);
         }
-
+       
         // Sort and make the unique list of diagnostics
         diagnostics.sort(compareDiagnostics);
         diagnostics = deduplicateSortedDiagnostics(diagnostics);
 
-        var returnCode = EmitReturnStatus.Succeeded;
-
-        // Check if there is any diagnostic in an error category; if so, there is an emitter error
+        // Update returnCode if there is any EmitterError
         var hasEmitterError = forEach(diagnostics, diagnostic => diagnostic.category === DiagnosticCategory.Error);
 
-        if (resolver.hasSemanticErrors() && !compilerOptions.declaration) {
-            // There is an semantic errror when output javascript file
-            // Output JS file with semantic error
-            returnCode = EmitReturnStatus.JSGeneratedWithSemanticErrors;
-        }
-        else if (resolver.hasSemanticErrors() && compilerOptions.declaration) {
-            // There is an semantic errror when output javascript and declaration file
-            // Output JS file with semantic error, not output declaration file
-            returnCode = EmitReturnStatus.DeclarationGenerationSkipped;
-        }
-        else if (hasEmitterError) {
+        if (hasEmitterError) {
             returnCode = EmitReturnStatus.EmitErrorsEncountered;
         }
 

src/compiler/types.ts

@@ -612,7 +612,7 @@ module ts {
         getSymbolCount(): number;
         getTypeCount(): number;
         checkProgram(): void;
-        emitFiles(): EmitResult;
+        emitFiles(targetSourceFile?: SourceFile): EmitResult;
         getParentOfSymbol(symbol: Symbol): Symbol;
         getTypeOfSymbol(symbol: Symbol): Type;
         getPropertiesOfType(type: Type): Symbol[];
@@ -671,7 +671,6 @@ module ts {
         getNodeCheckFlags(node: Node): NodeCheckFlags;
         getEnumMemberValue(node: EnumMember): number;
         hasSemanticErrors(): boolean;
-        shouldEmitDeclarations(): boolean;
         isDeclarationVisible(node: Declaration): boolean;
         isImplementationOfOverload(node: FunctionDeclaration): boolean;
         writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;