--outFile & --module concatenation

Jakefile.js

@@ -228,7 +228,7 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
 function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, outDir, preserveConstEnums, keepComments, noResolve, stripInternal, callback) {
     file(outFile, prereqs, function() {
         var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
-        var options = "--module commonjs --noImplicitAny --noEmitOnError --pretty";
+        var options = "--noImplicitAny --noEmitOnError --pretty";
 
         // Keep comments when specifically requested
         // or when in debug mode.
@@ -251,6 +251,9 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOu
         if (!noOutFile) {
             options += " --out " + outFile;
         }
+        else {
+            options += " --module commonjs"
+        }
 
         if(noResolve) {
             options += " --noResolve";

src/compiler/checker.ts

@@ -14931,10 +14931,20 @@ namespace ts {
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
                 isOptionalParameter,
-                isArgumentsLocalBinding
+                isArgumentsLocalBinding,
+                getExternalModuleFileFromDeclaration
             };
         }
 
+        function getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration): SourceFile {
+                const specifier = getExternalModuleName(declaration);
+                const moduleSymbol = getSymbolAtLocation(specifier);
+                if (!moduleSymbol) {
+                    return undefined;
+                }
+                return getDeclarationOfKind(moduleSymbol, SyntaxKind.SourceFile) as SourceFile;
+        }
+
         function initializeTypeChecker() {
             // Bind all source files and propagate errors
             forEach(host.getSourceFiles(), file => {

src/compiler/declarationEmitter.ts

@@ -58,8 +58,9 @@ namespace ts {
         let errorNameNode: DeclarationName;
         const emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
         const emit = compilerOptions.stripInternal ? stripInternal : emitNode;
+        let noDeclare = !root;
 
-        const moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
+        let moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
         let asynchronousSubModuleDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];
 
         // Contains the reference paths that needs to go in the declaration file.
@@ -107,26 +108,60 @@ namespace ts {
         else {
             // Emit references corresponding to this file
             const emittedReferencedFiles: SourceFile[] = [];
+            let prevModuleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
             forEach(host.getSourceFiles(), sourceFile => {
-                if (!isExternalModuleOrDeclarationFile(sourceFile)) {
+                if (!isDeclarationFile(sourceFile)) {
                     // Check what references need to be added
                     if (!compilerOptions.noResolve) {
                         forEach(sourceFile.referencedFiles, fileReference => {
                             const referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
 
-                            // If the reference file is a declaration file or an external module, emit that reference
-                            if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) &&
+                            // If the reference file is a declaration file, emit that reference
+                            if (referencedFile && (isDeclarationFile(referencedFile) &&
                                 !contains(emittedReferencedFiles, referencedFile))) { // If the file reference was not already emitted
 
                                 writeReferencePath(referencedFile);
                                 emittedReferencedFiles.push(referencedFile);
                             }
                         });
                     }
+                }
 
+                if (!isExternalModuleOrDeclarationFile(sourceFile)) {
+                    noDeclare = false;
+                    emitSourceFile(sourceFile);
+                }
+                else if (isExternalModule(sourceFile)) {
+                    noDeclare = true;
+                    write(`declare module "${getResolvedExternalModuleName(host, sourceFile)}" {`);
+                    writeLine();
+                    increaseIndent();
                     emitSourceFile(sourceFile);
+                    decreaseIndent();
+                    write("}");
+                    writeLine();
+
+                    // create asynchronous output for the importDeclarations
+                    if (moduleElementDeclarationEmitInfo.length) {
+                        const oldWriter = writer;
+                        forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {
+                            if (aliasEmitInfo.isVisible && !aliasEmitInfo.asynchronousOutput) {
+                                Debug.assert(aliasEmitInfo.node.kind === SyntaxKind.ImportDeclaration);
+                                createAndSetNewTextWriterWithSymbolWriter();
+                                Debug.assert(aliasEmitInfo.indent === 1);
+                                increaseIndent();
+                                writeImportDeclaration(<ImportDeclaration>aliasEmitInfo.node);
+                                aliasEmitInfo.asynchronousOutput = writer.getText();
+                                decreaseIndent();
+                            }
+                        });
+                        setWriter(oldWriter);
+                    }
+                    prevModuleElementDeclarationEmitInfo = prevModuleElementDeclarationEmitInfo.concat(moduleElementDeclarationEmitInfo);
+                    moduleElementDeclarationEmitInfo = [];
                 }
             });
+            moduleElementDeclarationEmitInfo = moduleElementDeclarationEmitInfo.concat(prevModuleElementDeclarationEmitInfo);
         }
 
         return {
@@ -607,7 +642,7 @@ namespace ts {
                 if (node.flags & NodeFlags.Default) {
                     write("default ");
                 }
-                else if (node.kind !== SyntaxKind.InterfaceDeclaration) {
+                else if (node.kind !== SyntaxKind.InterfaceDeclaration && !noDeclare) {
                     write("declare ");
                 }
             }
@@ -702,11 +737,25 @@ namespace ts {
                 }
                 write(" from ");
             }
-            writeTextOfNode(currentText, node.moduleSpecifier);
+            emitExternalModuleSpecifier(node.moduleSpecifier);
             write(";");
             writer.writeLine();
         }
 
+        function emitExternalModuleSpecifier(moduleSpecifier: Expression) {
+            if (moduleSpecifier.kind === SyntaxKind.StringLiteral && (!root) && (compilerOptions.out || compilerOptions.outFile)) {
+                const moduleName = getExternalModuleNameFromDeclaration(host, resolver, moduleSpecifier.parent as (ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration));
+                if (moduleName) {
+                    write("\"");
+                    write(moduleName);
+                    write("\"");
+                    return;
+                }
+            }
+
+            writeTextOfNode(currentText, moduleSpecifier);
+        }
+
         function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
             if (node.propertyName) {
                 writeTextOfNode(currentText, node.propertyName);
@@ -738,7 +787,7 @@ namespace ts {
             }
             if (node.moduleSpecifier) {
                 write(" from ");
-                writeTextOfNode(currentText, node.moduleSpecifier);
+                emitExternalModuleSpecifier(node.moduleSpecifier);
             }
             write(";");
             writer.writeLine();

src/compiler/diagnosticMessages.json

@@ -2310,7 +2310,6 @@
         "category": "Message",
         "code": 6078
     },
-
     "Specify JSX code generation: 'preserve' or 'react'": {
         "category": "Message",
         "code": 6080
@@ -2319,7 +2318,10 @@
         "category": "Message",
         "code": 6081
     },
-
+    "Only 'amd' and 'system' modules are supported alongside --{0}.": {
+        "category": "Error",
+        "code": 6082
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005