JavaScript LS scaffolding + JS module inference

lib/lib.core.d.ts

@@ -1198,6 +1198,22 @@ interface PromiseLike<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
 }
 
+
+declare namespace CommonJS {
+    export var require: Require;
+
+    export var exports: any;
+
+    interface Exports { }
+    interface Module {
+      exports: Exports;
+    }
+
+    interface Require {
+        (moduleName: string): any;
+    }
+}
+
 interface ArrayLike<T> {
     length: number;
     [n: number]: T;

lib/lib.core.es6.d.ts

@@ -1198,6 +1198,22 @@ interface PromiseLike<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
 }
 
+
+declare namespace CommonJS {
+    export var require: Require;
+
+    export var exports: any;
+
+    interface Exports { }
+    interface Module {
+      exports: Exports;
+    }
+
+    interface Require {
+        (moduleName: string): any;
+    }
+}
+
 interface ArrayLike<T> {
     length: number;
     [n: number]: T;

lib/lib.d.ts

@@ -1198,6 +1198,22 @@ interface PromiseLike<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
 }
 
+
+declare namespace CommonJS {
+    export var require: Require;
+
+    export var exports: any;
+
+    interface Exports { }
+    interface Module {
+      exports: Exports;
+    }
+
+    interface Require {
+        (moduleName: string): any;
+    }
+}
+
 interface ArrayLike<T> {
     length: number;
     [n: number]: T;

lib/lib.es6.d.ts

@@ -1198,6 +1198,22 @@ interface PromiseLike<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
 }
 
+
+declare namespace CommonJS {
+    export var require: Require;
+
+    export var exports: any;
+
+    interface Exports { }
+    interface Module {
+      exports: Exports;
+    }
+
+    interface Require {
+        (moduleName: string): any;
+    }
+}
+
 interface ArrayLike<T> {
     length: number;
     [n: number]: T;

lib/tsc.js

@@ -650,6 +650,7 @@ var ts;
     }
     ts.fileExtensionIs = fileExtensionIs;
     ts.supportedExtensions = [".ts", ".tsx", ".d.ts"];
+    ts.supportedJsExtensions = ts.supportedExtensions.concat(".js", ".jsx");
     var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     function removeFileExtension(path) {
         for (var _i = 0; _i < extensionsToRemove.length; _i++) {

src/compiler/binder.ts

@@ -6,8 +6,8 @@ namespace ts {
 
     export const enum ModuleInstanceState {
         NonInstantiated = 0,
-        Instantiated    = 1,
-        ConstEnumOnly   = 2
+        Instantiated = 1,
+        ConstEnumOnly = 2
     }
 
     export function getModuleInstanceState(node: Node): ModuleInstanceState {
@@ -90,6 +90,8 @@ namespace ts {
         let lastContainer: Node;
         let seenThisKeyword: boolean;
 
+        let isJavaScriptFile = isSourceFileJavaScript(file);
+
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
         // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
@@ -164,6 +166,9 @@ namespace ts {
                     return "__export";
                 case SyntaxKind.ExportAssignment:
                     return (<ExportAssignment>node).isExportEquals ? "export=" : "default";
+                case SyntaxKind.BinaryExpression:
+                    // Binary expression case is for JS module 'module.exports = expr'
+                    return "export=";
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.ClassDeclaration:
                     return node.flags & NodeFlags.Default ? "default" : undefined;
@@ -779,7 +784,7 @@ namespace ts {
             return "__" + indexOf((<SignatureDeclaration>node.parent).parameters, node);
         }
 
-        function bind(node: Node) {
+        function bind(node: Node): void {
             node.parent = parent;
 
             let savedInStrictMode = inStrictMode;
@@ -851,9 +856,18 @@ namespace ts {
 
         function bindWorker(node: Node) {
             switch (node.kind) {
+                /* Strict mode checks */
                 case SyntaxKind.Identifier:
                     return checkStrictModeIdentifier(<Identifier>node);
                 case SyntaxKind.BinaryExpression:
+                    if (isJavaScriptFile) {
+                        if (isExportsPropertyAssignment(node)) {
+                            bindExportsPropertyAssignment(<BinaryExpression>node);
+                        }
+                        else if (isModuleExportsAssignment(node)) {
+                            bindModuleExportsAssignment(<BinaryExpression>node);
+                        }
+                    }
                     return checkStrictModeBinaryExpression(<BinaryExpression>node);
                 case SyntaxKind.CatchClause:
                     return checkStrictModeCatchClause(<CatchClause>node);
@@ -919,6 +933,14 @@ namespace ts {
                     checkStrictModeFunctionName(<FunctionExpression>node);
                     let bindingName = (<FunctionExpression>node).name ? (<FunctionExpression>node).name.text : "__function";
                     return bindAnonymousDeclaration(<FunctionExpression>node, SymbolFlags.Function, bindingName);
+
+                case SyntaxKind.CallExpression:
+                    if (isJavaScriptFile) {
+                        bindCallExpression(<CallExpression>node);
+                    }
+                    break;
+
+                // Members of classes, interfaces, and modules
                 case SyntaxKind.ClassExpression:
                 case SyntaxKind.ClassDeclaration:
                     return bindClassLikeDeclaration(<ClassLikeDeclaration>node);
@@ -930,6 +952,8 @@ namespace ts {
                     return bindEnumDeclaration(<EnumDeclaration>node);
                 case SyntaxKind.ModuleDeclaration:
                     return bindModuleDeclaration(<ModuleDeclaration>node);
+
+                // Imports and exports
                 case SyntaxKind.ImportEqualsDeclaration:
                 case SyntaxKind.NamespaceImport:
                 case SyntaxKind.ImportSpecifier:
@@ -949,16 +973,21 @@ namespace ts {
         function bindSourceFileIfExternalModule() {
             setExportContextFlag(file);
             if (isExternalModule(file)) {
-                bindAnonymousDeclaration(file, SymbolFlags.ValueModule, `"${removeFileExtension(file.fileName)}"`);
+                bindSourceFileAsExternalModule();
             }
         }
 
-        function bindExportAssignment(node: ExportAssignment) {
+        function bindSourceFileAsExternalModule() {
+            bindAnonymousDeclaration(file, SymbolFlags.ValueModule, `"${removeFileExtension(file.fileName) }"`);
+        }
+
+        function bindExportAssignment(node: ExportAssignment|BinaryExpression) {
+            let boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
             if (!container.symbol || !container.symbol.exports) {
                 // Export assignment in some sort of block construct
                 bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
             }
-            else if (node.expression.kind === SyntaxKind.Identifier) {
+            else if (boundExpression.kind === SyntaxKind.Identifier) {
                 // An export default clause with an identifier exports all meanings of that identifier
                 declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
             }
@@ -985,6 +1014,34 @@ namespace ts {
             }
         }
 
+        function setCommonJsModuleIndicator(node: Node) {
+            if (!file.commonJsModuleIndicator) {
+                file.commonJsModuleIndicator = node;
+                bindSourceFileAsExternalModule();
+            }
+        }
+
+        function bindExportsPropertyAssignment(node: BinaryExpression) {
+            // When we create a property via 'exports.foo = bar', the 'exports.foo' property access
+            // expression is the declaration
+            setCommonJsModuleIndicator(node);
+            declareSymbol(file.symbol.exports, file.symbol, <PropertyAccessExpression>node.left, SymbolFlags.Property | SymbolFlags.Export, SymbolFlags.None);
+        }
+
+        function bindModuleExportsAssignment(node: BinaryExpression) {
+            // 'module.exports = expr' assignment
+            setCommonJsModuleIndicator(node);
+            bindExportAssignment(node);
+        }
+
+        function bindCallExpression(node: CallExpression) {
+            // We're only inspecting call expressions to detect CommonJS modules, so we can skip
+            // this check if we've already seen the module indicator
+            if (!file.commonJsModuleIndicator && isRequireCall(node)) {
+                setCommonJsModuleIndicator(node);
+            }
+        }
+
         function bindClassLikeDeclaration(node: ClassLikeDeclaration) {
             if (node.kind === SyntaxKind.ClassDeclaration) {
                 bindBlockScopedDeclaration(node, SymbolFlags.Class, SymbolFlags.ClassExcludes);