Inline const enum in import equals declaration

src/compiler/checker.ts

@@ -41611,22 +41611,19 @@ namespace ts {
             return getNodeLinks(node).enumMemberValue;
         }
 
-        function canHaveConstantValue(node: Node): node is EnumMember | AccessExpression {
-            switch (node.kind) {
-                case SyntaxKind.EnumMember:
-                case SyntaxKind.PropertyAccessExpression:
-                case SyntaxKind.ElementAccessExpression:
-                    return true;
-            }
-            return false;
+        function canHaveConstantValue(node: Node): node is EnumMember | EntityName | AccessExpression {
+            return isEnumMember(node) || isEntityName(node) || isAccessExpression(node);
         }
 
-        function getConstantValue(node: EnumMember | AccessExpression): string | number | undefined {
+        function getConstantValue(node: EnumMember | EntityName | AccessExpression): string | number | undefined {
             if (node.kind === SyntaxKind.EnumMember) {
                 return getEnumMemberValue(node);
             }
 
-            const symbol = getNodeLinks(node).resolvedSymbol;
+            // Cached name resolution result of import equals declaration/access expression
+            const symbol = isEntityName(node)
+                ? isDeclaration(node.parent) && resolveAlias(getSymbolOfNode(node.parent))
+                : getNodeLinks(node).resolvedSymbol;
             if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
                 // inline property\index accesses only for const enums
                 const member = symbol.valueDeclaration as EnumMember;

src/compiler/factory/utilities.ts

@@ -162,7 +162,7 @@ namespace ts {
             const left = createExpressionFromEntityName(factory, node.left);
             // TODO(rbuckton): Does this need to be parented?
             const right = setParent(setTextRange(factory.cloneNode(node.right), node.right), node.right.parent);
-            return setTextRange(factory.createPropertyAccessExpression(left, right), node);
+            return setOriginalNode(setTextRange(factory.createPropertyAccessExpression(left, right), node), node);
         }
         else {
             // TODO(rbuckton): Does this need to be parented?

src/compiler/transformers/ts.ts

@@ -3342,10 +3342,9 @@ namespace ts {
 
                 const substitute = typeof constantValue === "string" ? factory.createStringLiteral(constantValue) : factory.createNumericLiteral(constantValue);
                 if (!compilerOptions.removeComments) {
-                    const originalNode = getOriginalNode(node, isAccessExpression);
-                    const propertyName = isPropertyAccessExpression(originalNode)
-                        ? declarationNameToString(originalNode.name)
-                        : getTextOfNode(originalNode.argumentExpression);
+                    const propertyName = getPropertyNameForPropertyNameNode(
+                        isPropertyAccessExpression(node) ? node.name : (node.argumentExpression as PropertyName)
+                    );
 
                     addSyntheticTrailingComment(substitute, SyntaxKind.MultiLineCommentTrivia, ` ${propertyName} `);
                 }

tests/baselines/reference/constEnumPropertyAccess1.js

@@ -38,7 +38,7 @@ var o = {
     1: true
 };
 var a = 1 /* A */;
-var a1 = 1 /* "A" */;
+var a1 = 1 /* A */;
 var g = o[1 /* A */];
 class C {
     [1 /* A */]() { }

tests/baselines/reference/constEnumSyntheticNodesComments.js

@@ -26,11 +26,11 @@ function verify(a) {
     switch (a) {
         case 0 /* A */:
             return assert(a);
-        case 1 /* "B" */:
+        case 1 /* B */:
             return assert(a);
-        case 2 /* `C` */:
+        case 2 /* C */:
             return assert(a);
-        case 3 /* "\u{44}" */:
+        case 3 /* D */:
             return assert(a);
     }
 }

tests/baselines/reference/constEnumToStringWithComments.js

@@ -24,14 +24,14 @@ let c1 = Foo["C"].toString();
 
 //// [constEnumToStringWithComments.js]
 var x0 = 100 /* X */.toString();
-var x1 = 100 /* "X" */.toString();
+var x1 = 100 /* X */.toString();
 var y0 = 0.5 /* Y */.toString();
-var y1 = 0.5 /* "Y" */.toString();
+var y1 = 0.5 /* Y */.toString();
 var z0 = 2 /* Z */.toString();
-var z1 = 2 /* "Z" */.toString();
+var z1 = 2 /* Z */.toString();
 var a0 = -1 /* A */.toString();
-var a1 = -1 /* "A" */.toString();
+var a1 = -1 /* A */.toString();
 var b0 = -1.5 /* B */.toString();
-var b1 = -1.5 /* "B" */.toString();
+var b1 = -1.5 /* B */.toString();
 var c0 = -1 /* C */.toString();
-var c1 = -1 /* "C" */.toString();
+var c1 = -1 /* C */.toString();

tests/baselines/reference/constEnums.js

@@ -208,8 +208,8 @@ function foo(x) {
         case -1 /* Q */:
         case 0 /* R */:
         case 0 /* S */:
-        case 11 /* "T" */:
-        case 11 /* `U` */:
+        case 11 /* T */:
+        case 11 /* U */:
         case 11 /* V */:
         case 11 /* W */:
         case 100 /* W1 */:

tests/baselines/reference/constIndexedAccess.js

@@ -35,8 +35,8 @@ var s = test[0];
 var n = test[1];
 var s1 = test[0 /* zero */];
 var n1 = test[1 /* one */];
-var s2 = test[0 /* "zero" */];
-var n2 = test[1 /* "one" */];
+var s2 = test[0 /* zero */];
+var n2 = test[1 /* one */];
 var numbersNotConst;
 (function (numbersNotConst) {
     numbersNotConst[numbersNotConst["zero"] = 0] = "zero";