fix(1632): erase const enums after inlining

Author: a-tarasyuk

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.IsolatedModules == TSTrue || options.VerbatimModuleSyntax == TSTrue
 }
 
 func (options *CompilerOptions) GetAllowJS() bool {

internal/transformers/tstransforms/runtimesyntax.go

@@ -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.Factory().NewNotEmittedStatement()
+	}
+
 	statements := []*ast.Statement{}
 
 	// If needed, we should emit a variable declaration for the enum:
@@ -1130,6 +1134,10 @@ 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 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) {

internal/transformers/tstransforms/typeeraser.go

@@ -343,6 +343,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/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/blockScopedEnumVariablesUseBeforeDef.js.diff

@@ -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>

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

@@ -7,16 +7,4 @@
 -"use strict";
  function f1(a, b) {
      const x1 = cast(a, isC); // cast<A, C>
-     const x2 = cast(b, isC); // cast<A, C>
-@@= skipped -35, +34 lines =@@
- 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>
+     const x2 = cast(b, isC); // cast<A, C>