fix(1632): erase const enums after inlining

internal/core/compileroptions.go

@@ -277,7 +277,7 @@ func (options *CompilerOptions) GetResolveJsonModule() bool {
 }
 
 func (options *CompilerOptions) ShouldPreserveConstEnums() bool {
-	return options.PreserveConstEnums == TSTrue || options.IsolatedModules == TSTrue
+	return options.PreserveConstEnums == TSTrue || options.GetIsolatedModules()
 }
 
 func (options *CompilerOptions) GetAllowJS() bool {

internal/printer/emitcontext.go

@@ -92,6 +92,7 @@ func (c *EmitContext) NewNodeVisitor(visit func(node *ast.Node) *ast.Node) *ast.
 		VisitFunctionBody:       c.VisitFunctionBody,
 		VisitIterationBody:      c.VisitIterationBody,
 		VisitTopLevelStatements: c.VisitVariableEnvironment,
+		VisitEmbeddedStatement:  c.VisitEmbeddedStatement,
 	})
 }
 
@@ -908,7 +909,7 @@ func (c *EmitContext) VisitIterationBody(body *ast.Statement, visitor *ast.NodeV
 	}
 
 	c.StartLexicalEnvironment()
-	updated := visitor.VisitEmbeddedStatement(body)
+	updated := c.VisitEmbeddedStatement(body, visitor)
 	if updated == nil {
 		panic("Expected visitor to return a statement.")
 	}
@@ -928,6 +929,21 @@ func (c *EmitContext) VisitIterationBody(body *ast.Statement, visitor *ast.NodeV
 	return updated
 }
 
+func (c *EmitContext) VisitEmbeddedStatement(node *ast.Statement, visitor *ast.NodeVisitor) *ast.Statement {
+	embeddedStatement := visitor.VisitEmbeddedStatement(node)
+	if embeddedStatement == nil {
+		return nil
+	}
+	if ast.IsNotEmittedStatement(embeddedStatement) {
+		emptyStatement := visitor.Factory.NewEmptyStatement()
+		emptyStatement.Loc = node.Loc
+		c.SetOriginal(emptyStatement, node)
+		c.AssignCommentRange(emptyStatement, node)
+		return emptyStatement
+	}
+	return embeddedStatement
+}
+
 func (c *EmitContext) SetSyntheticLeadingComments(node *ast.Node, comments []SynthesizedComment) *ast.Node {
 	c.emitNodes.Get(node).leadingComments = comments
 	return node
@@ -961,3 +977,11 @@ func (c *EmitContext) GetSyntheticTrailingComments(node *ast.Node) []Synthesized
 	}
 	return nil
 }
+
+func (c *EmitContext) NewNotEmittedStatement(node *ast.Node) *ast.Statement {
+	statement := c.Factory.NewNotEmittedStatement()
+	statement.Loc = node.Loc
+	c.SetOriginal(statement, node)
+	c.AssignCommentRange(statement, node)
+	return statement
+}

internal/transformers/tstransforms/runtimesyntax.go

@@ -64,7 +64,7 @@ func (tx *RuntimeSyntaxTransformer) pushScope(node *ast.Node) (savedCurrentScope
 	case ast.KindCaseBlock, ast.KindModuleBlock, ast.KindBlock:
 		tx.currentScope = node
 		tx.currentScopeFirstDeclarationsOfName = nil
-	case ast.KindFunctionDeclaration, ast.KindClassDeclaration, ast.KindEnumDeclaration, ast.KindModuleDeclaration, ast.KindVariableStatement:
+	case ast.KindFunctionDeclaration, ast.KindClassDeclaration, ast.KindVariableStatement:
 		tx.recordDeclarationInScope(node)
 	}
 	return savedCurrentScope, savedCurrentScopeFirstDeclarationsOfName
@@ -309,6 +309,10 @@ func (tx *RuntimeSyntaxTransformer) addVarForDeclaration(statements []*ast.State
 }
 
 func (tx *RuntimeSyntaxTransformer) visitEnumDeclaration(node *ast.EnumDeclaration) *ast.Node {
+	if !tx.shouldEmitEnumDeclaration(node) {
+		return tx.EmitContext().NewNotEmittedStatement(node.AsNode())
+	}
+
 	statements := []*ast.Statement{}
 
 	// If needed, we should emit a variable declaration for the enum:
@@ -553,6 +557,10 @@ func (tx *RuntimeSyntaxTransformer) transformEnumMember(
 }
 
 func (tx *RuntimeSyntaxTransformer) visitModuleDeclaration(node *ast.ModuleDeclaration) *ast.Node {
+	if !tx.shouldEmitModuleDeclaration(node) {
+		return tx.EmitContext().NewNotEmittedStatement(node.AsNode())
+	}
+
 	statements := []*ast.Statement{}
 
 	// If needed, we should emit a variable declaration for the module:
@@ -1130,6 +1138,19 @@ func (tx *RuntimeSyntaxTransformer) evaluateEntity(node *ast.Node, location *ast
 	return result
 }
 
+func (tx *RuntimeSyntaxTransformer) shouldEmitEnumDeclaration(node *ast.EnumDeclaration) bool {
+	return !ast.IsEnumConst(node.AsNode()) || tx.compilerOptions.ShouldPreserveConstEnums()
+}
+
+func (tx *RuntimeSyntaxTransformer) shouldEmitModuleDeclaration(node *ast.ModuleDeclaration) bool {
+	pn := tx.EmitContext().ParseNode(node.AsNode())
+	if pn == nil {
+		// If we can't find a parse tree node, assume the node is instantiated.
+		return true
+	}
+	return isInstantiatedModule(node.AsNode(), tx.compilerOptions.ShouldPreserveConstEnums())
+}
+
 func getInnermostModuleDeclarationFromDottedModule(moduleDeclaration *ast.ModuleDeclaration) *ast.ModuleDeclaration {
 	for moduleDeclaration.Body != nil && moduleDeclaration.Body.Kind == ast.KindModuleDeclaration {
 		moduleDeclaration = moduleDeclaration.Body.AsModuleDeclaration()

internal/transformers/tstransforms/runtimesyntax_test.go

@@ -200,11 +200,7 @@ var E;
     E[E["B"] = 1] = "B";
 })(E || (E = {}));`},
 
-		{title: "const enum", input: "const enum E {A, B}", output: `var E;
-(function (E) {
-    E[E["A"] = 0] = "A";
-    E[E["B"] = 1] = "B";
-})(E || (E = {}));`},
+		{title: "const enum", input: "const enum E {A, B}", output: ""},
 
 		{title: "merged enum", input: "enum E {A} enum E {B=A}", output: `var E;
 (function (E) {
@@ -250,9 +246,7 @@ func TestNamespaceTransformer(t *testing.T) {
 		input  string
 		output string
 	}{
-		{title: "empty namespace", input: "namespace N {}", output: `var N;
-(function (N) {
-})(N || (N = {}));`},
+		{title: "empty namespace", input: "namespace N {}", output: ``},
 
 		{title: "export var", input: "namespace N { export var x = 1; }", output: `var N;
 (function (N) {
@@ -363,19 +357,9 @@ func TestNamespaceTransformer(t *testing.T) {
     })(E = N.E || (N.E = {}));
 })(N || (N = {}));`},
 
-		{title: "export namespace", input: "namespace N { export namespace N2 {} }", output: `var N;
-(function (N) {
-    let N2;
-    (function (N2) {
-    })(N2 = N.N2 || (N.N2 = {}));
-})(N || (N = {}));`},
+		{title: "export namespace", input: "namespace N { export namespace N2 {} }", output: ``},
 
-		{title: "nested namespace", input: "namespace N.N2 { }", output: `var N;
-(function (N) {
-    let N2;
-    (function (N2) {
-    })(N2 = N.N2 || (N.N2 = {}));
-})(N || (N = {}));`},
+		{title: "nested namespace", input: "namespace N.N2 { }", output: ``},
 
 		{title: "import=", input: "import X = Y.X;", output: `var X = Y.X;`},
 

internal/transformers/tstransforms/typeeraser.go

@@ -35,10 +35,7 @@ func (tx *TypeEraserTransformer) popNode(grandparentNode *ast.Node) {
 }
 
 func (tx *TypeEraserTransformer) elide(node *ast.Statement) *ast.Statement {
-	statement := tx.Factory().NewNotEmittedStatement()
-	tx.EmitContext().SetOriginal(statement, node)
-	statement.Loc = node.Loc
-	return statement
+	return tx.EmitContext().NewNotEmittedStatement(node.AsNode())
 }
 
 func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
@@ -343,6 +340,12 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
 		}
 		return node
 
+	case ast.KindEnumDeclaration:
+		if ast.IsEnumConst(node) {
+			return node
+		}
+		return tx.Visitor().VisitEachChild(node)
+
 	default:
 		return tx.Visitor().VisitEachChild(node)
 	}

testdata/baselines/reference/compiler/constEnumInEmbeddedStatements.js

@@ -0,0 +1,14 @@
+//// [tests/cases/compiler/constEnumInEmbeddedStatements.ts] ////
+
+//// [constEnumInEmbeddedStatements.ts]
+function t(x: number) {
+    if (x)
+        /* before E */ const enum E { A = 1 } /* after E */
+}
+
+
+//// [constEnumInEmbeddedStatements.js]
+function t(x) {
+    if (x)
+        /* before E */ ; /* after E */
+}

testdata/baselines/reference/compiler/constEnumInEmbeddedStatements.symbols

@@ -0,0 +1,15 @@
+//// [tests/cases/compiler/constEnumInEmbeddedStatements.ts] ////
+
+=== constEnumInEmbeddedStatements.ts ===
+function t(x: number) {
+>t : Symbol(t, Decl(constEnumInEmbeddedStatements.ts, 0, 0))
+>x : Symbol(x, Decl(constEnumInEmbeddedStatements.ts, 0, 11))
+
+    if (x)
+>x : Symbol(x, Decl(constEnumInEmbeddedStatements.ts, 0, 11))
+
+        /* before E */ const enum E { A = 1 } /* after E */
+>E : Symbol(E, Decl(constEnumInEmbeddedStatements.ts, 1, 10))
+>A : Symbol(E.A, Decl(constEnumInEmbeddedStatements.ts, 2, 37))
+}
+

testdata/baselines/reference/compiler/constEnumInEmbeddedStatements.types

@@ -0,0 +1,16 @@
+//// [tests/cases/compiler/constEnumInEmbeddedStatements.ts] ////
+
+=== constEnumInEmbeddedStatements.ts ===
+function t(x: number) {
+>t : (x: number) => void
+>x : number
+
+    if (x)
+>x : number
+
+        /* before E */ const enum E { A = 1 } /* after E */
+>E : E
+>A : E.A
+>1 : 1
+}
+

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=false).js

@@ -0,0 +1,9 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+//// [constEnumInNamespace.ts]
+namespace N {
+  export const enum E { A = 0 }
+}
+
+
+//// [constEnumInNamespace.js]

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=false).symbols

@@ -0,0 +1,11 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+=== constEnumInNamespace.ts ===
+namespace N {
+>N : Symbol(N, Decl(constEnumInNamespace.ts, 0, 0))
+
+  export const enum E { A = 0 }
+>E : Symbol(E, Decl(constEnumInNamespace.ts, 0, 13))
+>A : Symbol(E.A, Decl(constEnumInNamespace.ts, 1, 23))
+}
+

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=false).types

@@ -0,0 +1,10 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+=== constEnumInNamespace.ts ===
+namespace N {
+  export const enum E { A = 0 }
+>E : E
+>A : E.A
+>0 : 0
+}
+

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=true).js

@@ -0,0 +1,16 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+//// [constEnumInNamespace.ts]
+namespace N {
+  export const enum E { A = 0 }
+}
+
+
+//// [constEnumInNamespace.js]
+var N;
+(function (N) {
+    let E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E = N.E || (N.E = {}));
+})(N || (N = {}));

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=true).symbols

@@ -0,0 +1,11 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+=== constEnumInNamespace.ts ===
+namespace N {
+>N : Symbol(N, Decl(constEnumInNamespace.ts, 0, 0))
+
+  export const enum E { A = 0 }
+>E : Symbol(E, Decl(constEnumInNamespace.ts, 0, 13))
+>A : Symbol(E.A, Decl(constEnumInNamespace.ts, 1, 23))
+}
+

testdata/baselines/reference/conformance/constEnumInNamespace(preserveconstenums=true).types

@@ -0,0 +1,10 @@
+//// [tests/cases/conformance/constEnums/constEnumInNamespace.ts] ////
+
+=== constEnumInNamespace.ts ===
+namespace N {
+  export const enum E { A = 0 }
+>E : E
+>A : E.A
+>0 : 0
+}
+

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

@@ -22,12 +22,6 @@ bar(new B);
 
 
 //// [assignmentNonObjectTypeConstraints.js]
-var E;
-(function (E) {
-    E[E["A"] = 0] = "A";
-    E[E["B"] = 1] = "B";
-    E[E["C"] = 2] = "C";
-})(E || (E = {}));
 function foo(x) {
     var y = x; // Ok
 }

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

@@ -1,18 +1,6 @@
 --- old.assignmentNonObjectTypeConstraints.js
 +++ new.assignmentNonObjectTypeConstraints.js
-@@= skipped -21, +21 lines =@@
-
-
- //// [assignmentNonObjectTypeConstraints.js]
-+var E;
-+(function (E) {
-+    E[E["A"] = 0] = "A";
-+    E[E["B"] = 1] = "B";
-+    E[E["C"] = 2] = "C";
-+})(E || (E = {}));
- function foo(x) {
-     var y = x; // Ok
- }
+@@= skipped -27, +27 lines =@@
  foo(5);
  foo(0 /* E.A */);
  class A {

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

@@ -30,15 +30,7 @@ function foo1() {
 }
 function foo2() {
     return 0 /* E.A */;
-    let E;
-    (function (E) {
-        E[E["A"] = 0] = "A";
-    })(E || (E = {}));
 }
 const config = {
     a: 2 /* AfterObject.A */,
 };
-var AfterObject;
-(function (AfterObject) {
-    AfterObject[AfterObject["A"] = 2] = "A";
-})(AfterObject || (AfterObject = {}));

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

@@ -156,11 +156,5 @@ function foo(node) {
 function bar(node) {
     const a = tryCast(node, isExpression); // tryCast<Expression, Node>
 }
-// Repro from #49924
-var SyntaxKind1;
-(function (SyntaxKind1) {
-    SyntaxKind1[SyntaxKind1["ClassExpression"] = 0] = "ClassExpression";
-    SyntaxKind1[SyntaxKind1["ClassStatement"] = 1] = "ClassStatement";
-})(SyntaxKind1 || (SyntaxKind1 = {}));
 const maybeClassStatement = tryCast(statement, isClassLike); // ClassLike1
 const x = tryCast(types, isNodeArray); // NodeAray<TypeNode>