Only mark const enums as references with preserveConstEnums on in export assignments

Author: weswigham

src/compiler/checker.ts

@@ -17809,8 +17809,12 @@ namespace ts {
             return type;
         }
 
+        function isExportOrExportExpression(location: Node) {
+            return !!findAncestor(location, e => e.parent && isExportAssignment(e.parent) && e.parent.expression === e && isEntityNameExpression(e));
+        }
+
         function markAliasReferenced(symbol: Symbol, location: Node) {
-            if (isNonLocalAlias(symbol, /*excludes*/ SymbolFlags.Value) && !isInTypeQuery(location) && (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol)))) {
+            if (isNonLocalAlias(symbol, /*excludes*/ SymbolFlags.Value) && !isInTypeQuery(location) && ((compilerOptions.preserveConstEnums && isExportOrExportExpression(location)) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol)))) {
                 markAliasSymbolAsReferenced(symbol);
             }
         }

tests/baselines/reference/amdModuleConstEnumUsage.js

@@ -0,0 +1,40 @@
+//// [tests/cases/compiler/amdModuleConstEnumUsage.ts] ////
+
+//// [cc.ts]
+export const enum CharCode {
+    A,
+    B
+}
+//// [file.ts]
+import { CharCode } from 'defs/cc';
+export class User {
+    method(input: number) {
+        if (CharCode.A === input) {}
+    }
+}
+
+
+//// [cc.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    exports.__esModule = true;
+    var CharCode;
+    (function (CharCode) {
+        CharCode[CharCode["A"] = 0] = "A";
+        CharCode[CharCode["B"] = 1] = "B";
+    })(CharCode = exports.CharCode || (exports.CharCode = {}));
+});
+//// [file.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    exports.__esModule = true;
+    var User = /** @class */ (function () {
+        function User() {
+        }
+        User.prototype.method = function (input) {
+            if (0 /* A */ === input) { }
+        };
+        return User;
+    }());
+    exports.User = User;
+});

tests/baselines/reference/amdModuleConstEnumUsage.symbols

@@ -0,0 +1,29 @@
+=== /proj/defs/cc.ts ===
+export const enum CharCode {
+>CharCode : Symbol(CharCode, Decl(cc.ts, 0, 0))
+
+    A,
+>A : Symbol(CharCode.A, Decl(cc.ts, 0, 28))
+
+    B
+>B : Symbol(CharCode.B, Decl(cc.ts, 1, 6))
+}
+=== /proj/component/file.ts ===
+import { CharCode } from 'defs/cc';
+>CharCode : Symbol(CharCode, Decl(file.ts, 0, 8))
+
+export class User {
+>User : Symbol(User, Decl(file.ts, 0, 35))
+
+    method(input: number) {
+>method : Symbol(User.method, Decl(file.ts, 1, 19))
+>input : Symbol(input, Decl(file.ts, 2, 11))
+
+        if (CharCode.A === input) {}
+>CharCode.A : Symbol(CharCode.A, Decl(cc.ts, 0, 28))
+>CharCode : Symbol(CharCode, Decl(file.ts, 0, 8))
+>A : Symbol(CharCode.A, Decl(cc.ts, 0, 28))
+>input : Symbol(input, Decl(file.ts, 2, 11))
+    }
+}
+

tests/baselines/reference/amdModuleConstEnumUsage.types

@@ -0,0 +1,30 @@
+=== /proj/defs/cc.ts ===
+export const enum CharCode {
+>CharCode : CharCode
+
+    A,
+>A : CharCode.A
+
+    B
+>B : CharCode.B
+}
+=== /proj/component/file.ts ===
+import { CharCode } from 'defs/cc';
+>CharCode : typeof CharCode
+
+export class User {
+>User : User
+
+    method(input: number) {
+>method : (input: number) => void
+>input : number
+
+        if (CharCode.A === input) {}
+>CharCode.A === input : boolean
+>CharCode.A : CharCode.A
+>CharCode : typeof CharCode
+>A : CharCode.A
+>input : number
+    }
+}
+

tests/cases/compiler/amdModuleConstEnumUsage.ts

@@ -0,0 +1,16 @@
+// @module: amd
+// @preserveConstEnums: true
+// @baseUrl: /proj
+// @filename: /proj/defs/cc.ts
+export const enum CharCode {
+    A,
+    B
+}
+// @filename: /proj/component/file.ts
+
+import { CharCode } from 'defs/cc';
+export class User {
+    method(input: number) {
+        if (CharCode.A === input) {}
+    }
+}