Fix various module emit differences

internal/binder/binder.go

@@ -794,8 +794,11 @@ func (b *Binder) bindModuleDeclaration(node *ast.Node) {
 		state := b.declareModuleSymbol(node)
 		if state != ast.ModuleInstanceStateNonInstantiated {
 			symbol := node.AsModuleDeclaration().Symbol
-			if symbol.Flags&(ast.SymbolFlagsFunction|ast.SymbolFlagsClass|ast.SymbolFlagsRegularEnum) != 0 || state != ast.ModuleInstanceStateConstEnumOnly {
-				// if module was already merged with some function, class or non-const enum, treat it as non-const-enum-only
+			if (symbol.Flags&(ast.SymbolFlagsFunction|ast.SymbolFlagsClass|ast.SymbolFlagsRegularEnum) == 0) &&
+				state == ast.ModuleInstanceStateConstEnumOnly &&
+				symbol.Flags&ast.SymbolFlagsConstEnumOnlyModule == 0 {
+				symbol.Flags |= ast.SymbolFlagsConstEnumOnlyModule
+			} else {
 				symbol.Flags &^= ast.SymbolFlagsConstEnumOnlyModule
 			}
 		}

internal/checker/emitresolver.go

@@ -762,7 +762,7 @@ func (r *emitResolver) IsTopLevelValueImportEqualsWithEntityName(node *ast.Node)
 		return false
 	}
 	if ast.IsImportEqualsDeclaration(node) &&
-		(ast.NodeIsMissing(node.AsImportEqualsDeclaration().ModuleReference) || node.AsImportEqualsDeclaration().ModuleReference.Kind != ast.KindExternalModuleReference) {
+		(ast.NodeIsMissing(node.AsImportEqualsDeclaration().ModuleReference) || node.AsImportEqualsDeclaration().ModuleReference.Kind == ast.KindExternalModuleReference) {
 		return false
 	}
 

internal/transformers/moduletransforms/commonjsmodule.go

@@ -1080,7 +1080,14 @@ func (tx *CommonJSModuleTransformer) visitTopLevelVariableStatement(node *ast.Va
 					propertyAccess,
 					v.Name().Clone(tx.Factory()),
 				))
+			} else if ast.IsIdentifier(v.Name()) {
+				expression := tx.transformInitializedVariable(v)
+				if expression != nil {
+					pushExpression(tx.Visitor().VisitNode(expression))
+				}
 			} else {
+				// For binding patterns, we can't do exports.{pattern} = value
+				// Just emit the assignment and let appendExportsOfVariableStatement handle the exports
 				expression := transformers.ConvertVariableDeclarationToAssignmentExpression(tx.EmitContext(), v)
 				if expression != nil {
 					pushExpression(tx.Visitor().VisitNode(expression))
@@ -1096,6 +1103,21 @@ func (tx *CommonJSModuleTransformer) visitTopLevelVariableStatement(node *ast.Va
 	return tx.visitTopLevelNestedVariableStatement(node)
 }
 
+func (tx *CommonJSModuleTransformer) transformInitializedVariable(node *ast.VariableDeclaration) *ast.Expression {
+	if node.Initializer == nil {
+		return nil
+	}
+	name := node.Name()
+	propertyAccess := tx.Factory().NewPropertyAccessExpression(
+		tx.Factory().NewIdentifier("exports"),
+		nil, /*questionDotToken*/
+		name,
+		ast.NodeFlagsNone,
+	)
+	tx.EmitContext().AssignCommentAndSourceMapRanges(propertyAccess, name)
+	return tx.Factory().NewAssignmentExpression(propertyAccess, node.Initializer)
+}
+
 // Visits a top-level nested variable statement as it may contain `var` declarations that are hoisted and may still be
 // exported with `export {}`.
 func (tx *CommonJSModuleTransformer) visitTopLevelNestedVariableStatement(node *ast.VariableStatement) *ast.Node {

internal/transformers/tstransforms/importelision.go

@@ -27,8 +27,16 @@ func NewImportElisionTransformer(opt *transformers.TransformOptions) *transforme
 func (tx *ImportElisionTransformer) visit(node *ast.Node) *ast.Node {
 	switch node.Kind {
 	case ast.KindImportEqualsDeclaration:
-		if !tx.isElisionBlocked(node) && !tx.shouldEmitImportEqualsDeclaration(node.AsImportEqualsDeclaration()) {
-			return nil
+		if !tx.isElisionBlocked(node) {
+			if ast.IsExternalModuleImportEqualsDeclaration(node) {
+				if !tx.shouldEmitAliasDeclaration(node) {
+					return nil
+				}
+			} else {
+				if !tx.shouldEmitImportEqualsDeclaration(node.AsImportEqualsDeclaration()) {
+					return nil
+				}
+			}
 		}
 		return tx.Visitor().VisitEachChild(node)
 	case ast.KindImportDeclaration:
@@ -124,16 +132,10 @@ func (tx *ImportElisionTransformer) shouldEmitAliasDeclaration(node *ast.Node) b
 }
 
 func (tx *ImportElisionTransformer) shouldEmitImportEqualsDeclaration(node *ast.ImportEqualsDeclaration) bool {
-	if !tx.shouldEmitAliasDeclaration(node.AsNode()) {
-		return false
-	}
-	if node.ModuleReference.Kind == ast.KindExternalModuleReference {
-		return true
-	}
 	// preserve old compiler's behavior: emit import declaration (even if we do not consider them referenced) when
 	// - current file is not external module
 	// - import declaration is top level and target is value imported by entity name
-	return tx.currentSourceFile != nil && ast.IsExternalModule(tx.currentSourceFile) && tx.isTopLevelValueImportEqualsWithEntityName(node.AsNode())
+	return tx.shouldEmitAliasDeclaration(node.AsNode()) || (!ast.IsExternalModule(tx.currentSourceFile) && tx.isTopLevelValueImportEqualsWithEntityName(node.AsNode()))
 }
 
 func (tx *ImportElisionTransformer) isReferencedAliasDeclaration(node *ast.Node) bool {

testdata/baselines/reference/compiler/exportDestructuring.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/exportDestructuring.ts] ////
+
+//// [exportDestructuring.ts]
+const arr = [1, 2];
+export const [a, b] = arr;
+
+
+//// [exportDestructuring.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.b = exports.a = void 0;
+const arr = [1, 2];
+[exports.a, exports.b] = arr;

testdata/baselines/reference/compiler/exportDestructuring.symbols

@@ -0,0 +1,11 @@
+//// [tests/cases/compiler/exportDestructuring.ts] ////
+
+=== exportDestructuring.ts ===
+const arr = [1, 2];
+>arr : Symbol(arr, Decl(exportDestructuring.ts, 0, 5))
+
+export const [a, b] = arr;
+>a : Symbol(a, Decl(exportDestructuring.ts, 1, 14))
+>b : Symbol(b, Decl(exportDestructuring.ts, 1, 16))
+>arr : Symbol(arr, Decl(exportDestructuring.ts, 0, 5))
+

testdata/baselines/reference/compiler/exportDestructuring.types

@@ -0,0 +1,14 @@
+//// [tests/cases/compiler/exportDestructuring.ts] ////
+
+=== exportDestructuring.ts ===
+const arr = [1, 2];
+>arr : number[]
+>[1, 2] : number[]
+>1 : 1
+>2 : 2
+
+export const [a, b] = arr;
+>a : number
+>b : number
+>arr : number[]
+

testdata/baselines/reference/submodule/compiler/aliasBug.js

@@ -37,6 +37,8 @@ var foo;
         })(baz = bar.baz || (bar.baz = {}));
     })(bar = foo.bar || (foo.bar = {}));
 })(foo || (foo = {}));
+var provide = foo;
+var booz = foo.bar.baz;
 var p = new provide.Provide();
 function use() {
     var p1; // error here, but should be okay

testdata/baselines/reference/submodule/compiler/aliasErrors.js

@@ -48,9 +48,15 @@ var foo;
         })(baz = bar.baz || (bar.baz = {}));
     })(bar = foo.bar || (foo.bar = {}));
 })(foo || (foo = {}));
+var provide = foo;
+var booz = foo.bar.baz;
+var beez = foo.bar;
+var m = no;
+var m2 = no.mod;
 5;
 "s";
 null;
+var r = undefined;
 var p = new provide.Provide();
 function use() {
     beez.baz.boo;

testdata/baselines/reference/submodule/compiler/chainedImportAlias.js

@@ -24,4 +24,5 @@ var m;
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const x = require("./chainedImportAlias_file0");
+var y = x;
 y.m.foo();

testdata/baselines/reference/submodule/compiler/collisionExportsRequireAndInternalModuleAliasInGlobalFile.js

@@ -31,6 +31,8 @@ var mOfGloalFile;
     }
     mOfGloalFile.c = c;
 })(mOfGloalFile || (mOfGloalFile = {}));
+var exports = mOfGloalFile.c;
+var require = mOfGloalFile.c;
 new exports();
 new require();
 var m1;

testdata/baselines/reference/submodule/compiler/collisionThisExpressionAndAliasInGlobal.js

@@ -13,3 +13,4 @@ var a;
     a.b = 10;
 })(a || (a = {}));
 var f = () => this;
+var _this = a; // Error

testdata/baselines/reference/submodule/compiler/constEnums.js

@@ -192,6 +192,7 @@ var A2;
         })(C = B.C || (B.C = {}));
     })(B = A2.B || (A2.B = {}));
 })(A2 || (A2 = {}));
+var I2 = A2.B;
 function foo0(e) {
     if (e === 1 /* I.V1 */) {
     }

testdata/baselines/reference/submodule/compiler/constructorWithIncompleteTypeAnnotation.js

@@ -282,6 +282,7 @@ TypeScriptAllInOne.Program.Main();
 
 
 //// [constructorWithIncompleteTypeAnnotation.js]
+var fs = module;
 ("fs");
 var TypeScriptAllInOne;
 (function (TypeScriptAllInOne) {

testdata/baselines/reference/submodule/compiler/constructorWithIncompleteTypeAnnotation.js.diff

@@ -1,11 +1,6 @@
 --- old.constructorWithIncompleteTypeAnnotation.js
 +++ new.constructorWithIncompleteTypeAnnotation.js
-@@= skipped -281, +281 lines =@@
-
-
- //// [constructorWithIncompleteTypeAnnotation.js]
--var fs = module;
- ("fs");
+@@= skipped -286, +286 lines =@@
  var TypeScriptAllInOne;
  (function (TypeScriptAllInOne) {
      class Program {
@@ -15,7 +10,7 @@
          static Main(...args) {
              try {
                  var bfs = new BasicFeatures();
-@@= skipped -15, +11 lines =@@
+@@= skipped -10, +7 lines =@@
                  retValue = bfs.VARIABLES();
                  if (retValue != 0)
                       ^= {

testdata/baselines/reference/submodule/compiler/declFileExportAssignmentImportInternalModule.js

@@ -28,6 +28,7 @@ export = m;
 var m3;
 (function (m3) {
 })(m3 || (m3 = {}));
+var m = m3;
 module.exports = m;
 
 

testdata/baselines/reference/submodule/compiler/declFileForExportedImport.js

@@ -18,9 +18,11 @@ exports.x = void 0;
 //// [declFileForExportedImport_1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.b = void 0;
 ///<reference path='declFileForExportedImport_0.ts'/>
 exports.a = require("./declFileForExportedImport_0");
 var y = exports.a.x;
+exports.b = exports.a;
 var z = exports.b.x;
 
 

testdata/baselines/reference/submodule/compiler/declFileImportChainInExportAssignment.js

@@ -22,6 +22,8 @@ var m;
         c_1.c = c;
     })(c = m.c || (m.c = {}));
 })(m || (m = {}));
+var a = m.c;
+var b = a;
 module.exports = b;
 
 

testdata/baselines/reference/submodule/compiler/declarationEmitEnumReferenceViaImportEquals.js

@@ -45,6 +45,7 @@ var Translation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Test = void 0;
 const translation_1 = require("./translation");
+var TranslationKeyEnum = translation_1.Translation.TranslationKeyEnum;
 class Test {
     TranslationKeyEnum = TranslationKeyEnum;
     print() {

testdata/baselines/reference/submodule/compiler/declarationEmitEnumReferenceViaImportEquals.js.diff

@@ -1,10 +1,8 @@
 --- old.declarationEmitEnumReferenceViaImportEquals.js
 +++ new.declarationEmitEnumReferenceViaImportEquals.js
-@@= skipped -44, +44 lines =@@
- Object.defineProperty(exports, "__esModule", { value: true });
- exports.Test = void 0;
+@@= skipped -46, +46 lines =@@
  const translation_1 = require("./translation");
--var TranslationKeyEnum = translation_1.Translation.TranslationKeyEnum;
+ var TranslationKeyEnum = translation_1.Translation.TranslationKeyEnum;
  class Test {
 -    constructor() {
 -        this.TranslationKeyEnum = TranslationKeyEnum;

testdata/baselines/reference/submodule/compiler/declarationEmitUnknownImport.js

@@ -8,6 +8,8 @@ export {Foo}
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Foo = void 0;
+var Foo = SomeNonExistingName;
+exports.Foo = Foo;
 
 
 //// [declarationEmitUnknownImport.d.ts]