Allow references to const enums when provably emitted via preserveConstEnums

Author: jakebailey

src/compiler/checker.ts

@@ -33884,7 +33884,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             return objectType;
         }
 
-        if (isConstEnumObjectType(objectType) && !isStringLiteralLike(indexExpression)) {
+        if (isConstEnumObjectType(objectType) && !isStringLiteralLike(indexExpression) && !isUseOfPreservedConstEnum(node, objectType)) {
             error(indexExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
             return errorType;
         }
@@ -39815,18 +39815,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 (node.parent.kind === SyntaxKind.TypeQuery && (node.parent as TypeQueryNode).exprName === node)) ||
             (node.parent.kind === SyntaxKind.ExportSpecifier); // We allow reexporting const enums
 
-        if (!ok) {
-            error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
+        if (!ok || getIsolatedModules(compilerOptions)) {
+            if (!isUseOfPreservedConstEnum(node, type)) {
+                if (!ok) {
+                    // TODO(jakebailey): make error message mention const enum preservation
+                    error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
+                }
+                else if (type.symbol.valueDeclaration!.flags & NodeFlags.Ambient && !isValidTypeOnlyAliasUseSite(node)) {
+                    error(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
+                }
+            }
         }
+    }
 
-        if (getIsolatedModules(compilerOptions)) {
-            Debug.assert(!!(type.symbol.flags & SymbolFlags.ConstEnum));
-            const constEnumDeclaration = type.symbol.valueDeclaration as EnumDeclaration;
-            const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
-            if (constEnumDeclaration.flags & NodeFlags.Ambient && !isValidTypeOnlyAliasUseSite(node) && (!redirect || !shouldPreserveConstEnums(redirect.commandLine.options))) {
-                error(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
+    function isUseOfPreservedConstEnum(use: Node, enumType: Type) {
+        Debug.assert(!!(enumType.symbol.flags & SymbolFlags.ConstEnum));
+        const constEnumDeclaration = enumType.symbol.valueDeclaration as EnumDeclaration;
+        const otherFile = getSourceFileOfNode(constEnumDeclaration);
+        if (!otherFile.isDeclarationFile) {
+            // This file can only have come from the current project.
+            if (constEnumDeclaration.flags & NodeFlags.Ambient && !isValidTypeOnlyAliasUseSite(use)) {
+                return false;
             }
+            return shouldPreserveConstEnums(compilerOptions);
         }
+        const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(otherFile.resolvedPath);
+        return redirect && shouldPreserveConstEnums(redirect.commandLine.options);
     }
 
     function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type {

tests/baselines/reference/constEnumUsedAsValue(preserveconstenums=true).errors.txt

@@ -27,8 +27,8 @@ E;
 >  : ^^^^^^^^
 
 E[x];
->E[x] : any
->     : ^^^
+>E[x] : string
+>     : ^^^^^^
 >E : typeof E
 >  : ^^^^^^^^
 >x : E

tests/baselines/reference/constEnumUsedAsValue(preserveconstenums=true).types

@@ -71,30 +71,7 @@ export const enum E2 { A = 1 }
 
 Output::
 /lib/tsc --p src/project
-src/project/index.ts:5:21 - error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query.
-
-5                     E; declare const x: E; E[x];
-                      ~
-
-src/project/index.ts:5:46 - error TS2476: A const enum member can only be accessed using a string literal.
-
-5                     E; declare const x: E; E[x];
-                                               ~
-
-src/project/index.ts:7:21 - error TS2475: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query.
-
-7                     E2; declare const y: E2; E2[y];
-                      ~~
-
-src/project/index.ts:7:49 - error TS2476: A const enum member can only be accessed using a string literal.
-
-7                     E2; declare const y: E2; E2[y];
-                                                  ~
-
-
-Found 4 errors in the same file, starting at: src/project/index.ts:5
-
-exitCode:: ExitStatus.DiagnosticsPresent_OutputsGenerated
+exitCode:: ExitStatus.Success
 
 
 //// [/src/project/index.js]

tests/baselines/reference/tsc/projectReferences/referencing-ambient-const-enum-as-value-from-referenced-project-with-preserveConstEnums.js

@@ -371,60 +371,7 @@ Info seq  [hh:mm:ss:mss] event:
       "event": "semanticDiag",
       "body": {
         "file": "/user/username/projects/project/src/project/index.ts",
-        "diagnostics": [
-          {
-            "start": {
-              "line": 5,
-              "offset": 13
-            },
-            "end": {
-              "line": 5,
-              "offset": 14
-            },
-            "text": "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query.",
-            "code": 2475,
-            "category": "error"
-          },
-          {
-            "start": {
-              "line": 5,
-              "offset": 38
-            },
-            "end": {
-              "line": 5,
-              "offset": 39
-            },
-            "text": "A const enum member can only be accessed using a string literal.",
-            "code": 2476,
-            "category": "error"
-          },
-          {
-            "start": {
-              "line": 7,
-              "offset": 13
-            },
-            "end": {
-              "line": 7,
-              "offset": 15
-            },
-            "text": "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query.",
-            "code": 2475,
-            "category": "error"
-          },
-          {
-            "start": {
-              "line": 7,
-              "offset": 41
-            },
-            "end": {
-              "line": 7,
-              "offset": 42
-            },
-            "text": "A const enum member can only be accessed using a string literal.",
-            "code": 2476,
-            "category": "error"
-          }
-        ]
+        "diagnostics": []
       }
     }
 After running Immedidate callback:: count: 1