Inline const enum in import equals declaration

Author: jablko

src/compiler/checker.ts

@@ -41611,22 +41611,18 @@ 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;
+            const symbol = isEntityName(node)
+                ? resolveEntityName(node, SymbolFlags.EnumMember)
+                : 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 = isPropertyAccessExpression(node)
+                        ? declarationNameToString(node.name)
+                        : getTextOfNode(node.argumentExpression);
 
                     addSyntheticTrailingComment(substitute, SyntaxKind.MultiLineCommentTrivia, ` ${propertyName} `);
                 }