@typescript-deploys/pr-build 5.0.0-pr-51387-10 → 5.0.0-pr-51387-49

package/lib/tsc.js

@@ -15,10 +15,15 @@ and limitations under the License.
 
 
 "use strict";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20221102`;
+var version = `${versionMajorMinor}.0-insiders.20221107`;
 var NativeCollections;
 ((NativeCollections2) => {
   const globals = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : void 0;
@@ -1962,6 +1967,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
     })(BoxCharacter || (BoxCharacter = {}));
     let Connection;
     ((Connection2) => {
+      Connection2[Connection2["None"] = 0] = "None";
       Connection2[Connection2["Up"] = 1] = "Up";
       Connection2[Connection2["Down"] = 2] = "Down";
       Connection2[Connection2["Left"] = 4] = "Left";
@@ -2679,6 +2685,25 @@ try {
 }
 var perfLogger = (etwModule == null ? void 0 : etwModule.logEvent) ? etwModule : nullLogger;
 
+// src/compiler/_namespaces/ts.performance.ts
+var ts_performance_exports = {};
+__export(ts_performance_exports, {
+  clearMarks: () => clearMarks,
+  clearMeasures: () => clearMeasures,
+  createTimer: () => createTimer,
+  createTimerIf: () => createTimerIf,
+  disable: () => disable,
+  enable: () => enable,
+  forEachMark: () => forEachMark,
+  forEachMeasure: () => forEachMeasure,
+  getCount: () => getCount,
+  getDuration: () => getDuration,
+  isEnabled: () => isEnabled,
+  mark: () => mark,
+  measure: () => measure,
+  nullTimer: () => nullTimer
+});
+
 // src/compiler/performance.ts
 var perfHooks;
 var performanceImpl;
@@ -4824,7 +4849,7 @@ var sys = (() => {
     }
     let activeSession;
     let profilePath = "./profile.cpuprofile";
-    const Buffer = require("buffer").Buffer;
+    const Buffer2 = require("buffer").Buffer;
     const nodeVersion = getNodeMajorVersion();
     const isNode4OrLater = nodeVersion >= 4;
     const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
@@ -5022,7 +5047,7 @@ var sys = (() => {
       }
     }
     function bufferFrom(input, encoding) {
-      return Buffer.from && Buffer.from !== Int8Array.from ? Buffer.from(input, encoding) : new Buffer(input, encoding);
+      return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
     }
     function isFileSystemCaseSensitive() {
       if (platform === "win32" || platform === "win64") {
@@ -6205,7 +6230,7 @@ var Diagnostics = {
   The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, 1 /* Error */, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."),
   Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, 1 /* Error */, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."),
   Enum_declarations_must_all_be_const_or_non_const: diag(2473, 1 /* Error */, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."),
-  const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, 1 /* Error */, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."),
+  const_enum_member_initializers_must_be_constant_expressions: diag(2474, 1 /* Error */, "const_enum_member_initializers_must_be_constant_expressions_2474", "const enum member initializers must be constant expressions."),
   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: diag(2475, 1 /* Error */, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'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."),
   A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, 1 /* Error */, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."),
   const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, 1 /* Error */, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."),
@@ -6261,7 +6286,6 @@ var Diagnostics = {
   Object_is_possibly_undefined: diag(2532, 1 /* Error */, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."),
   Object_is_possibly_null_or_undefined: diag(2533, 1 /* Error */, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."),
   A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, 1 /* Error */, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."),
-  Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, 1 /* Error */, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."),
   Type_0_cannot_be_used_to_index_type_1: diag(2536, 1 /* Error */, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."),
   Type_0_has_no_matching_index_signature_for_type_1: diag(2537, 1 /* Error */, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."),
   Type_0_cannot_be_used_as_an_index_type: diag(2538, 1 /* Error */, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."),
@@ -7504,7 +7528,7 @@ var Diagnostics = {
   An_optional_chain_cannot_contain_private_identifiers: diag(18030, 1 /* Error */, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."),
   The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: diag(18031, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."),
   The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: diag(18032, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."),
-  Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead: diag(18033, 1 /* Error */, "Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhau_18033", "Only numeric enums can have computed members, but this expression has type '{0}'. If you do not need exhaustiveness checks, consider using an object literal instead."),
+  Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values: diag(18033, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values_18033", "Type '{0}' is not assignable to type '{1}' as required for computed enum member values."),
   Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, 3 /* Message */, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."),
   Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(18035, 1 /* Error */, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."),
   Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator: diag(18036, 1 /* Error */, "Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_dec_18036", "Class decorators can't be used with static private identifier. Consider removing the experimental decorator."),
@@ -14431,7 +14455,7 @@ function getLeftmostExpression(node, stopAtCallExpressions) {
     return node;
   }
 }
-function Symbol3(flags, name) {
+function Symbol4(flags, name) {
   this.flags = flags;
   this.escapedName = name;
   this.declarations = void 0;
@@ -14494,7 +14518,7 @@ var objectAllocator = {
   getIdentifierConstructor: () => Identifier2,
   getPrivateIdentifierConstructor: () => Node4,
   getSourceFileConstructor: () => Node4,
-  getSymbolConstructor: () => Symbol3,
+  getSymbolConstructor: () => Symbol4,
   getTypeConstructor: () => Type3,
   getSignatureConstructor: () => Signature2,
   getSourceMapSourceConstructor: () => SourceMapSource
@@ -16661,7 +16685,7 @@ function createNodeFactory(flags, baseFactory2) {
     createUnparsedPrepend,
     createUnparsedTextLike,
     createUnparsedSyntheticReference,
-    createInputFiles: createInputFiles2,
+    createInputFiles,
     createSyntheticExpression,
     createSyntaxList,
     createNotEmittedStatement,
@@ -19543,7 +19567,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.section = section;
     return node;
   }
-  function createInputFiles2() {
+  function createInputFiles() {
     const node = createBaseNode(311 /* InputFiles */);
     node.javascriptText = "";
     node.declarationText = "";
@@ -20424,69 +20448,64 @@ function parseOldFileOfCurrentEmit(bundleFileInfo) {
   node.helpers = map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, (name) => getAllUnscopedEmitHelpers().get(name));
   return node;
 }
-function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
+function createInputFilesWithFilePaths(readFileText, javascriptPath, javascriptMapPath, declarationPath, declarationMapPath, buildInfoPath, host, options) {
   const node = parseNodeFactory.createInputFiles();
-  if (!isString(javascriptTextOrReadFileText)) {
-    const cache = new Map();
-    const textGetter = (path) => {
-      if (path === void 0)
-        return void 0;
-      let value = cache.get(path);
-      if (value === void 0) {
-        value = javascriptTextOrReadFileText(path);
-        cache.set(path, value !== void 0 ? value : false);
-      }
-      return value !== false ? value : void 0;
-    };
-    const definedTextGetter = (path) => {
-      const result = textGetter(path);
-      return result !== void 0 ? result : `/* Input file ${path} was missing */\r
+  node.javascriptPath = javascriptPath;
+  node.javascriptMapPath = javascriptMapPath;
+  node.declarationPath = declarationPath;
+  node.declarationMapPath = declarationMapPath;
+  node.buildInfoPath = buildInfoPath;
+  const cache = new Map();
+  const textGetter = (path) => {
+    if (path === void 0)
+      return void 0;
+    let value = cache.get(path);
+    if (value === void 0) {
+      value = readFileText(path);
+      cache.set(path, value !== void 0 ? value : false);
+    }
+    return value !== false ? value : void 0;
+  };
+  const definedTextGetter = (path) => {
+    const result = textGetter(path);
+    return result !== void 0 ? result : `/* Input file ${path} was missing */\r
 `;
-    };
-    let buildInfo2;
-    const getAndCacheBuildInfo = (getText) => {
-      var _a2;
-      if (buildInfo2 === void 0) {
-        const result = getText();
-        buildInfo2 = result !== void 0 ? (_a2 = getBuildInfo(node.buildInfoPath, result)) != null ? _a2 : false : false;
+  };
+  let buildInfo;
+  const getAndCacheBuildInfo = () => {
+    var _a2, _b;
+    if (buildInfo === void 0 && buildInfoPath) {
+      if (host == null ? void 0 : host.getBuildInfo) {
+        buildInfo = (_a2 = host.getBuildInfo(buildInfoPath, options.configFilePath)) != null ? _a2 : false;
+      } else {
+        const result = textGetter(buildInfoPath);
+        buildInfo = result !== void 0 ? (_b = getBuildInfo(buildInfoPath, result)) != null ? _b : false : false;
       }
-      return buildInfo2 || void 0;
-    };
-    node.javascriptPath = declarationTextOrJavascriptPath;
-    node.javascriptMapPath = javascriptMapPath;
-    node.declarationPath = Debug.checkDefined(javascriptMapTextOrDeclarationPath);
-    node.declarationMapPath = declarationMapPath;
-    node.buildInfoPath = declarationMapTextOrBuildInfoPath;
-    Object.defineProperties(node, {
-      javascriptText: { get() {
-        return definedTextGetter(declarationTextOrJavascriptPath);
-      } },
-      javascriptMapText: { get() {
-        return textGetter(javascriptMapPath);
-      } },
-      declarationText: { get() {
-        return definedTextGetter(Debug.checkDefined(javascriptMapTextOrDeclarationPath));
-      } },
-      declarationMapText: { get() {
-        return textGetter(declarationMapPath);
-      } },
-      buildInfo: { get() {
-        return getAndCacheBuildInfo(() => textGetter(declarationMapTextOrBuildInfoPath));
-      } }
-    });
-  } else {
-    node.javascriptText = javascriptTextOrReadFileText;
-    node.javascriptMapPath = javascriptMapPath;
-    node.javascriptMapText = javascriptMapTextOrDeclarationPath;
-    node.declarationText = declarationTextOrJavascriptPath;
-    node.declarationMapPath = declarationMapPath;
-    node.declarationMapText = declarationMapTextOrBuildInfoPath;
-    node.javascriptPath = javascriptPath;
-    node.declarationPath = declarationPath;
-    node.buildInfoPath = buildInfoPath;
-    node.buildInfo = buildInfo;
-    node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
-  }
+    }
+    return buildInfo || void 0;
+  };
+  Object.defineProperties(node, {
+    javascriptText: { get: () => definedTextGetter(javascriptPath) },
+    javascriptMapText: { get: () => textGetter(javascriptMapPath) },
+    declarationText: { get: () => definedTextGetter(Debug.checkDefined(declarationPath)) },
+    declarationMapText: { get: () => textGetter(declarationMapPath) },
+    buildInfo: { get: getAndCacheBuildInfo }
+  });
+  return node;
+}
+function createInputFilesWithFileTexts(javascriptPath, javascriptText, javascriptMapPath, javascriptMapText, declarationPath, declarationText, declarationMapPath, declarationMapText, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
+  const node = parseNodeFactory.createInputFiles();
+  node.javascriptPath = javascriptPath;
+  node.javascriptText = javascriptText;
+  node.javascriptMapPath = javascriptMapPath;
+  node.javascriptMapText = javascriptMapText;
+  node.declarationPath = declarationPath;
+  node.declarationText = declarationText;
+  node.declarationMapPath = declarationMapPath;
+  node.declarationMapText = declarationMapText;
+  node.buildInfoPath = buildInfoPath;
+  node.buildInfo = buildInfo;
+  node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
   return node;
 }
 function setOriginalNode(node, original) {
@@ -34709,7 +34728,7 @@ function createBinder() {
   let inStrictMode;
   let inAssignmentPattern = false;
   let symbolCount = 0;
-  let Symbol11;
+  let Symbol12;
   let classifiableNames;
   const unreachableFlow = { flags: 1 /* Unreachable */ };
   const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
@@ -34725,7 +34744,7 @@ function createBinder() {
     inStrictMode = bindInStrictMode(file, opts);
     classifiableNames = new Set();
     symbolCount = 0;
-    Symbol11 = objectAllocator.getSymbolConstructor();
+    Symbol12 = objectAllocator.getSymbolConstructor();
     Debug.attachFlowNodeDebugInfo(unreachableFlow);
     Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
     if (!file.locals) {
@@ -34768,7 +34787,7 @@ function createBinder() {
   }
   function createSymbol(flags, name) {
     symbolCount++;
-    return new Symbol11(flags, name);
+    return new Symbol12(flags, name);
   }
   function addDeclarationToSymbol(symbol, node, symbolFlags) {
     symbol.flags |= symbolFlags;
@@ -38172,12 +38191,11 @@ function createTypeChecker(host) {
   let cancellationToken;
   let requestedExternalEmitHelpers;
   let externalHelpersModule;
-  const Symbol11 = objectAllocator.getSymbolConstructor();
+  const Symbol12 = objectAllocator.getSymbolConstructor();
   const Type7 = objectAllocator.getTypeConstructor();
   const Signature5 = objectAllocator.getSignatureConstructor();
   let typeCount = 0;
   let symbolCount = 0;
-  let enumCount = 0;
   let totalInstantiationCount = 0;
   let instantiationCount = 0;
   let instantiationDepth = 0;
@@ -38977,7 +38995,7 @@ function createTypeChecker(host) {
   }
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
-    const symbol = new Symbol11(flags | 33554432 /* Transient */, name);
+    const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
     symbol.checkFlags = checkFlags || 0;
     return symbol;
   }
@@ -40008,7 +40026,7 @@ function createTypeChecker(host) {
     }
   }
   function isSameScopeDescendentOf(initial, parent, stopAt) {
-    return !!parent && !!findAncestor(initial, (n) => n === parent || (n === stopAt || isFunctionLike(n) && !getImmediatelyInvokedFunctionExpression(n) ? "quit" : false));
+    return !!parent && !!findAncestor(initial, (n) => n === parent || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || isAsyncFunction(n)) ? "quit" : false));
   }
   function getAnyImportSyntax(node) {
     switch (node.kind) {
@@ -41281,6 +41299,11 @@ function createTypeChecker(host) {
     (_a2 = tracing) == null ? void 0 : _a2.recordType(result);
     return result;
   }
+  function createTypeWithSymbol(flags, symbol) {
+    const result = createType(flags);
+    result.symbol = symbol;
+    return result;
+  }
   function createOriginType(flags) {
     return new Type7(checker, flags);
   }
@@ -41291,9 +41314,8 @@ function createTypeChecker(host) {
     return type;
   }
   function createObjectType(objectFlags, symbol) {
-    const type = createType(524288 /* Object */);
+    const type = createTypeWithSymbol(524288 /* Object */, symbol);
     type.objectFlags = objectFlags;
-    type.symbol = symbol;
     type.members = void 0;
     type.properties = void 0;
     type.callSignatures = void 0;
@@ -41305,10 +41327,7 @@ function createTypeChecker(host) {
     return getUnionType(arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
   }
   function createTypeParameter(symbol) {
-    const type = createType(262144 /* TypeParameter */);
-    if (symbol)
-      type.symbol = symbol;
-    return type;
+    return createTypeWithSymbol(262144 /* TypeParameter */, symbol);
   }
   function isReservedMemberName(name) {
     return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) !== 95 /* _ */ && name.charCodeAt(2) !== 64 /* at */ && name.charCodeAt(2) !== 35 /* hash */;
@@ -41899,29 +41918,29 @@ function createTypeChecker(host) {
         context.approximateLength += 7;
         return factory.createKeywordTypeNode(134 /* BooleanKeyword */);
       }
-      if (type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */)) {
-        const parentSymbol = getParentOfSymbol(type.symbol);
-        const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
-        if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
-          return parentName;
-        }
-        const memberName = symbolName(type.symbol);
-        if (isIdentifierText(memberName, 0 /* ES3 */)) {
-          return appendReferenceToType(
-            parentName,
-            factory.createTypeReferenceNode(memberName, void 0)
-          );
-        }
-        if (isImportTypeNode(parentName)) {
-          parentName.isTypeOf = true;
-          return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
-        } else if (isTypeReferenceNode(parentName)) {
-          return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
-        } else {
-          return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
-        }
-      }
       if (type.flags & 1056 /* EnumLike */) {
+        if (type.symbol.flags & 8 /* EnumMember */) {
+          const parentSymbol = getParentOfSymbol(type.symbol);
+          const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
+          if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
+            return parentName;
+          }
+          const memberName = symbolName(type.symbol);
+          if (isIdentifierText(memberName, 0 /* ES3 */)) {
+            return appendReferenceToType(
+              parentName,
+              factory.createTypeReferenceNode(memberName, void 0)
+            );
+          }
+          if (isImportTypeNode(parentName)) {
+            parentName.isTypeOf = true;
+            return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
+          } else if (isTypeReferenceNode(parentName)) {
+            return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
+          } else {
+            return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
+          }
+        }
         return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
       }
       if (type.flags & 128 /* StringLiteral */) {
@@ -46260,91 +46279,36 @@ function createTypeChecker(host) {
     }
     return links.declaredType;
   }
-  function isStringConcatExpression(expr) {
-    if (isStringLiteralLike(expr)) {
-      return true;
-    } else if (expr.kind === 223 /* BinaryExpression */) {
-      return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right);
-    }
-    return false;
-  }
-  function isLiteralEnumMember(member) {
-    const expr = member.initializer;
-    if (!expr) {
-      return !(member.flags & 16777216 /* Ambient */);
-    }
-    switch (expr.kind) {
-      case 10 /* StringLiteral */:
-      case 8 /* NumericLiteral */:
-      case 14 /* NoSubstitutionTemplateLiteral */:
-        return true;
-      case 221 /* PrefixUnaryExpression */:
-        return expr.operator === 40 /* MinusToken */ && expr.operand.kind === 8 /* NumericLiteral */;
-      case 79 /* Identifier */:
-        return nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText);
-      case 223 /* BinaryExpression */:
-        return isStringConcatExpression(expr);
-      default:
-        return false;
-    }
-  }
-  function getEnumKind(symbol) {
-    const links = getSymbolLinks(symbol);
-    if (links.enumKind !== void 0) {
-      return links.enumKind;
-    }
-    let hasNonLiteralMember = false;
-    if (symbol.declarations) {
-      for (const declaration of symbol.declarations) {
-        if (declaration.kind === 263 /* EnumDeclaration */) {
-          for (const member of declaration.members) {
-            if (member.initializer && isStringLiteralLike(member.initializer)) {
-              return links.enumKind = 1 /* Literal */;
-            }
-            if (!isLiteralEnumMember(member)) {
-              hasNonLiteralMember = true;
-            }
-          }
-        }
-      }
-    }
-    return links.enumKind = hasNonLiteralMember ? 0 /* Numeric */ : 1 /* Literal */;
-  }
   function getBaseTypeOfEnumLiteralType(type) {
     return type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
   }
   function getDeclaredTypeOfEnum(symbol) {
     const links = getSymbolLinks(symbol);
-    if (links.declaredType) {
-      return links.declaredType;
-    }
-    if (getEnumKind(symbol) === 1 /* Literal */) {
-      enumCount++;
+    if (!links.declaredType) {
       const memberTypeList = [];
       if (symbol.declarations) {
         for (const declaration of symbol.declarations) {
           if (declaration.kind === 263 /* EnumDeclaration */) {
             for (const member of declaration.members) {
-              const value = getEnumMemberValue(member);
-              const memberType = getFreshTypeOfLiteralType(getEnumLiteralType(value !== void 0 ? value : 0, enumCount, getSymbolOfNode(member)));
-              getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
-              memberTypeList.push(getRegularTypeOfLiteralType(memberType));
+              if (hasBindableName(member)) {
+                const memberSymbol = getSymbolOfNode(member);
+                const value = getEnumMemberValue(member);
+                const memberType = value !== void 0 ? getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) : createTypeWithSymbol(32 /* Enum */, memberSymbol);
+                getSymbolLinks(memberSymbol).declaredType = memberType;
+                memberTypeList.push(getRegularTypeOfLiteralType(memberType));
+              }
             }
           }
         }
       }
-      if (memberTypeList.length) {
-        const enumType2 = getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0);
-        if (enumType2.flags & 1048576 /* Union */) {
-          enumType2.flags |= 1024 /* EnumLiteral */;
-          enumType2.symbol = symbol;
-        }
-        return links.declaredType = enumType2;
+      const enumType = memberTypeList.length ? getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0) : createTypeWithSymbol(32 /* Enum */, symbol);
+      if (enumType.flags & 1048576 /* Union */) {
+        enumType.flags |= 1024 /* EnumLiteral */;
+        enumType.symbol = symbol;
       }
+      links.declaredType = enumType;
     }
-    const enumType = createType(32 /* Enum */);
-    enumType.symbol = symbol;
-    return links.declaredType = enumType;
+    return links.declaredType;
   }
   function getDeclaredTypeOfEnumMember(symbol) {
     const links = getSymbolLinks(symbol);
@@ -48596,8 +48560,7 @@ function createTypeChecker(host) {
     return type;
   }
   function cloneTypeReference(source) {
-    const type = createType(source.flags);
-    type.symbol = source.symbol;
+    const type = createTypeWithSymbol(source.flags, source.symbol);
     type.objectFlags = source.objectFlags;
     type.target = source.target;
     type.resolvedTypeArguments = source.resolvedTypeArguments;
@@ -50145,8 +50108,7 @@ function createTypeChecker(host) {
     return result;
   }
   function createStringMappingType(symbol, type) {
-    const result = createType(268435456 /* StringMapping */);
-    result.symbol = symbol;
+    const result = createTypeWithSymbol(268435456 /* StringMapping */, symbol);
     result.type = type;
     return result;
   }
@@ -50960,8 +50922,7 @@ function createTypeChecker(host) {
     return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info;
   }
   function createLiteralType(flags, value, symbol, regularType) {
-    const type = createType(flags);
-    type.symbol = symbol;
+    const type = createTypeWithSymbol(flags, symbol);
     type.value = value;
     type.regularType = regularType || type;
     return type;
@@ -50998,8 +50959,7 @@ function createTypeChecker(host) {
   }
   function getEnumLiteralType(value, enumId, symbol) {
     let type;
-    const qualifier = typeof value === "string" ? "@" : "#";
-    const key = enumId + qualifier + value;
+    const key = `${enumId}${typeof value === "string" ? "@" : "#"}${value}`;
     const flags = 1024 /* EnumLiteral */ | (typeof value === "string" ? 128 /* StringLiteral */ : 256 /* NumberLiteral */);
     return enumLiteralTypes.get(key) || (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type);
   }
@@ -51014,8 +50974,7 @@ function createTypeChecker(host) {
     return links.resolvedType;
   }
   function createUniqueESSymbolType(symbol) {
-    const type = createType(8192 /* UniqueESSymbol */);
-    type.symbol = symbol;
+    const type = createTypeWithSymbol(8192 /* UniqueESSymbol */, symbol);
     type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
     return type;
   }
@@ -52256,19 +52215,20 @@ function createTypeChecker(host) {
   function isStringIndexSignatureOnlyType(type) {
     return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || type.flags & 3145728 /* UnionOrIntersection */ && every(type.types, isStringIndexSignatureOnlyType) || false;
   }
-  function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) {
+  function isEnumTypeRelatedTo(source, target, errorReporter) {
+    const sourceSymbol = source.flags & 8 /* EnumMember */ ? getParentOfSymbol(source) : source;
+    const targetSymbol = target.flags & 8 /* EnumMember */ ? getParentOfSymbol(target) : target;
     if (sourceSymbol === targetSymbol) {
       return true;
     }
+    if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
+      return false;
+    }
     const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
     const entry = enumRelation.get(id);
     if (entry !== void 0 && !(!(entry & 4 /* Reported */) && entry & 2 /* Failed */ && errorReporter)) {
       return !!(entry & 1 /* Succeeded */);
     }
-    if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
-      enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
-      return false;
-    }
     const targetEnumType = getTypeOfSymbol(targetSymbol);
     for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
       if (property.flags & 8 /* EnumMember */) {
@@ -52312,12 +52272,12 @@ function createTypeChecker(host) {
       return true;
     if (s & 12288 /* ESSymbolLike */ && t & 4096 /* ESSymbol */)
       return true;
-    if (s & 32 /* Enum */ && t & 32 /* Enum */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
+    if (s & 32 /* Enum */ && t & 32 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
       return true;
     if (s & 1024 /* EnumLiteral */ && t & 1024 /* EnumLiteral */) {
       if (s & 1048576 /* Union */ && t & 1048576 /* Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
         return true;
-      if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter))
+      if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
         return true;
     }
     if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */)))
@@ -53813,28 +53773,30 @@ function createTypeChecker(host) {
           }
           const sourceTypeArguments = getTypeArguments(source2);
           const targetTypeArguments = getTypeArguments(target2);
-          const startCount = Math.min(isTupleType(source2) ? getStartElementCount(source2.target, 11 /* NonRest */) : 0, getStartElementCount(target2.target, 11 /* NonRest */));
-          const endCount = Math.min(isTupleType(source2) ? getEndElementCount(source2.target, 11 /* NonRest */) : 0, targetRestFlag ? getEndElementCount(target2.target, 11 /* NonRest */) : 0);
+          const targetStartCount = getStartElementCount(target2.target, 11 /* NonRest */);
+          const targetEndCount = getEndElementCount(target2.target, 11 /* NonRest */);
+          const targetHasRestElement = target2.target.hasRestElement;
           let canExcludeDiscriminants = !!excludedProperties;
-          for (let i = 0; i < targetArity; i++) {
-            const sourceIndex = i < targetArity - endCount ? i : i + sourceArity - targetArity;
-            const sourceFlags = isTupleType(source2) && (i < startCount || i >= targetArity - endCount) ? source2.target.elementFlags[sourceIndex] : 4 /* Rest */;
-            const targetFlags = target2.target.elementFlags[i];
+          for (let sourcePosition = 0; sourcePosition < sourceArity; sourcePosition++) {
+            const sourceFlags = isTupleType(source2) ? source2.target.elementFlags[sourcePosition] : 4 /* Rest */;
+            const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
+            const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount) : sourcePosition;
+            const targetFlags = target2.target.elementFlags[targetPosition];
             if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */)) {
               if (reportErrors2) {
-                reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, i);
+                reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, targetPosition);
               }
               return 0 /* False */;
             }
             if (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */)) {
               if (reportErrors2) {
-                reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourceIndex, i);
+                reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourcePosition, targetPosition);
               }
               return 0 /* False */;
             }
             if (targetFlags & 1 /* Required */ && !(sourceFlags & 1 /* Required */)) {
               if (reportErrors2) {
-                reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, i);
+                reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, targetPosition);
               }
               return 0 /* False */;
             }
@@ -53842,20 +53804,20 @@ function createTypeChecker(host) {
               if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) {
                 canExcludeDiscriminants = false;
               }
-              if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + i))) {
+              if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + sourcePosition))) {
                 continue;
               }
             }
-            const sourceType = !isTupleType(source2) ? sourceTypeArguments[0] : i < startCount || i >= targetArity - endCount ? removeMissingType(sourceTypeArguments[sourceIndex], !!(sourceFlags & targetFlags & 2 /* Optional */)) : getElementTypeOfSliceOfTupleType(source2, startCount, endCount) || neverType;
-            const targetType = targetTypeArguments[i];
+            const sourceType = removeMissingType(sourceTypeArguments[sourcePosition], !!(sourceFlags & targetFlags & 2 /* Optional */));
+            const targetType = targetTypeArguments[targetPosition];
             const targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : removeMissingType(targetType, !!(targetFlags & 2 /* Optional */));
             const related = isRelatedTo(sourceType, targetCheckType, 3 /* Both */, reportErrors2, void 0, intersectionState);
             if (!related) {
               if (reportErrors2 && (targetArity > 1 || sourceArity > 1)) {
-                if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) {
-                  reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourceIndex, i);
+                if (targetHasRestElement && sourcePosition >= targetStartCount && sourcePositionFromEnd >= targetEndCount && targetStartCount !== sourceArity - targetEndCount - 1) {
+                  reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, targetStartCount, sourceArity - targetEndCount - 1, targetPosition);
                 } else {
-                  reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, startCount, sourceArity - endCount - 1, i);
+                  reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourcePosition, targetPosition);
                 }
               }
               return 0 /* False */;
@@ -55435,10 +55397,7 @@ function createTypeChecker(host) {
           return;
         }
         source = getUnionType(sources);
-      } else if (target.flags & 2097152 /* Intersection */ && some(
-        target.types,
-        (t) => !!getInferenceInfoForType(t) || isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)
-      )) {
+      } else if (target.flags & 2097152 /* Intersection */ && !every(target.types, isNonGenericObjectType)) {
         if (!(source.flags & 1048576 /* Union */)) {
           const [sources, targets] = inferFromMatchingTypes(source.flags & 2097152 /* Intersection */ ? source.types : [source], target.types, isTypeIdenticalTo);
           if (sources.length === 0 || targets.length === 0) {
@@ -62667,7 +62626,7 @@ function createTypeChecker(host) {
         if (symbol && symbol.flags & 2097152 /* Alias */) {
           symbol = resolveAlias(symbol);
         }
-        return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */ && getEnumKind(symbol) === 1 /* Literal */);
+        return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */);
     }
     return false;
   }
@@ -64592,7 +64551,7 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionCached(node, checkMode) {
-    if (checkMode && checkMode !== 0 /* Normal */) {
+    if (checkMode) {
       return checkExpression(node, checkMode);
     }
     const links = getNodeLinks(node);
@@ -65609,9 +65568,6 @@ function createTypeChecker(host) {
             symbol.escapedName
           );
         }
-        if (type.flags & 32 /* Enum */ && symbol.flags & 8 /* EnumMember */) {
-          error(node, Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type));
-        }
       }
     }
   }
@@ -68935,7 +68891,7 @@ function createTypeChecker(host) {
     if (member.initializer) {
       return computeConstantValue(member);
     }
-    if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0 /* Numeric */) {
+    if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent)) {
       return void 0;
     }
     if (autoValue !== void 0) {
@@ -68945,134 +68901,140 @@ function createTypeChecker(host) {
     return void 0;
   }
   function computeConstantValue(member) {
-    const enumKind = getEnumKind(getSymbolOfNode(member.parent));
     const isConstEnum = isEnumConst(member.parent);
     const initializer = member.initializer;
-    const value = enumKind === 1 /* Literal */ && !isLiteralEnumMember(member) ? void 0 : evaluate(initializer);
+    const value = evaluate(initializer, member);
     if (value !== void 0) {
       if (isConstEnum && typeof value === "number" && !isFinite(value)) {
         error(initializer, isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
       }
-    } else if (enumKind === 1 /* Literal */) {
-      error(initializer, Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members);
-      return 0;
     } else if (isConstEnum) {
-      error(initializer, Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values);
+      error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
     } else if (member.parent.flags & 16777216 /* Ambient */) {
       error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
     } else {
-      const source = checkExpression(initializer);
-      if (!isTypeAssignableToKind(source, 296 /* NumberLike */)) {
-        error(initializer, Diagnostics.Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead, typeToString(source));
-      } else {
-        checkTypeAssignableTo(source, getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, void 0);
-      }
+      checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
     }
     return value;
-    function evaluate(expr) {
-      switch (expr.kind) {
-        case 221 /* PrefixUnaryExpression */:
-          const value2 = evaluate(expr.operand);
-          if (typeof value2 === "number") {
-            switch (expr.operator) {
-              case 39 /* PlusToken */:
-                return value2;
-              case 40 /* MinusToken */:
-                return -value2;
-              case 54 /* TildeToken */:
-                return ~value2;
-            }
+  }
+  function evaluate(expr, location) {
+    switch (expr.kind) {
+      case 221 /* PrefixUnaryExpression */:
+        const value = evaluate(expr.operand, location);
+        if (typeof value === "number") {
+          switch (expr.operator) {
+            case 39 /* PlusToken */:
+              return value;
+            case 40 /* MinusToken */:
+              return -value;
+            case 54 /* TildeToken */:
+              return ~value;
           }
-          break;
-        case 223 /* BinaryExpression */:
-          const left = evaluate(expr.left);
-          const right = evaluate(expr.right);
-          if (typeof left === "number" && typeof right === "number") {
-            switch (expr.operatorToken.kind) {
-              case 51 /* BarToken */:
-                return left | right;
-              case 50 /* AmpersandToken */:
-                return left & right;
-              case 48 /* GreaterThanGreaterThanToken */:
-                return left >> right;
-              case 49 /* GreaterThanGreaterThanGreaterThanToken */:
-                return left >>> right;
-              case 47 /* LessThanLessThanToken */:
-                return left << right;
-              case 52 /* CaretToken */:
-                return left ^ right;
-              case 41 /* AsteriskToken */:
-                return left * right;
-              case 43 /* SlashToken */:
-                return left / right;
-              case 39 /* PlusToken */:
-                return left + right;
-              case 40 /* MinusToken */:
-                return left - right;
-              case 44 /* PercentToken */:
-                return left % right;
-              case 42 /* AsteriskAsteriskToken */:
-                return left ** right;
+        }
+        break;
+      case 223 /* BinaryExpression */:
+        const left = evaluate(expr.left, location);
+        const right = evaluate(expr.right, location);
+        if (typeof left === "number" && typeof right === "number") {
+          switch (expr.operatorToken.kind) {
+            case 51 /* BarToken */:
+              return left | right;
+            case 50 /* AmpersandToken */:
+              return left & right;
+            case 48 /* GreaterThanGreaterThanToken */:
+              return left >> right;
+            case 49 /* GreaterThanGreaterThanGreaterThanToken */:
+              return left >>> right;
+            case 47 /* LessThanLessThanToken */:
+              return left << right;
+            case 52 /* CaretToken */:
+              return left ^ right;
+            case 41 /* AsteriskToken */:
+              return left * right;
+            case 43 /* SlashToken */:
+              return left / right;
+            case 39 /* PlusToken */:
+              return left + right;
+            case 40 /* MinusToken */:
+              return left - right;
+            case 44 /* PercentToken */:
+              return left % right;
+            case 42 /* AsteriskAsteriskToken */:
+              return left ** right;
+          }
+        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 39 /* PlusToken */) {
+          return "" + left + right;
+        }
+        break;
+      case 10 /* StringLiteral */:
+      case 14 /* NoSubstitutionTemplateLiteral */:
+        return expr.text;
+      case 225 /* TemplateExpression */:
+        return evaluateTemplateExpression(expr, location);
+      case 8 /* NumericLiteral */:
+        checkGrammarNumericLiteral(expr);
+        return +expr.text;
+      case 214 /* ParenthesizedExpression */:
+        return evaluate(expr.expression, location);
+      case 79 /* Identifier */:
+        if (isInfinityOrNaNString(expr.escapedText)) {
+          return +expr.escapedText;
+        }
+      case 208 /* PropertyAccessExpression */:
+        if (isEntityNameExpression(expr)) {
+          const symbol = resolveEntityName(expr, 111551 /* Value */, true);
+          if (symbol) {
+            if (symbol.flags & 8 /* EnumMember */) {
+              return evaluateEnumMember(expr, symbol, location);
             }
-          } else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39 /* PlusToken */) {
-            return left + right;
-          }
-          break;
-        case 10 /* StringLiteral */:
-        case 14 /* NoSubstitutionTemplateLiteral */:
-          return expr.text;
-        case 8 /* NumericLiteral */:
-          checkGrammarNumericLiteral(expr);
-          return +expr.text;
-        case 214 /* ParenthesizedExpression */:
-          return evaluate(expr.expression);
-        case 79 /* Identifier */:
-          const identifier = expr;
-          if (isInfinityOrNaNString(identifier.escapedText)) {
-            return +identifier.escapedText;
-          }
-          return nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
-        case 209 /* ElementAccessExpression */:
-        case 208 /* PropertyAccessExpression */:
-          if (isConstantMemberAccess(expr)) {
-            const type = getTypeOfExpression(expr.expression);
-            if (type.symbol && type.symbol.flags & 384 /* Enum */) {
-              let name;
-              if (expr.kind === 208 /* PropertyAccessExpression */) {
-                name = expr.name.escapedText;
-              } else {
-                name = escapeLeadingUnderscores(cast(expr.argumentExpression, isLiteralExpression).text);
+            if (isConstVariable(symbol)) {
+              const declaration = symbol.valueDeclaration;
+              if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+                return evaluate(declaration.initializer, declaration);
               }
-              return evaluateEnumMember(expr, type.symbol, name);
             }
           }
-          break;
-      }
-      return void 0;
-    }
-    function evaluateEnumMember(expr, enumSymbol, name) {
-      const memberSymbol = enumSymbol.exports.get(name);
-      if (memberSymbol) {
-        const declaration = memberSymbol.valueDeclaration;
-        if (declaration !== member) {
-          if (declaration && isBlockScopedNameDeclaredBeforeUse(declaration, member) && isEnumDeclaration(declaration.parent)) {
-            return getEnumMemberValue(declaration);
+        }
+        break;
+      case 209 /* ElementAccessExpression */:
+        const root = expr.expression;
+        if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+          const rootSymbol = resolveEntityName(root, 111551 /* Value */, true);
+          if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
+            const name = escapeLeadingUnderscores(expr.argumentExpression.text);
+            const member = rootSymbol.exports.get(name);
+            if (member) {
+              return evaluateEnumMember(expr, member, location);
+            }
           }
-          error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
-          return 0;
-        } else {
-          error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol));
         }
-      }
+        break;
+    }
+    return void 0;
+  }
+  function evaluateEnumMember(expr, symbol, location) {
+    const declaration = symbol.valueDeclaration;
+    if (!declaration || declaration === location) {
+      error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
       return void 0;
     }
+    if (!isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+      error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
+      return 0;
+    }
+    return getEnumMemberValue(declaration);
   }
-  function isConstantMemberAccess(node) {
-    const type = getTypeOfExpression(node);
-    if (type === errorType) {
-      return false;
+  function evaluateTemplateExpression(expr, location) {
+    let result = expr.head.text;
+    for (const span of expr.templateSpans) {
+      const value = evaluate(span.expression, location);
+      if (value === void 0) {
+        return void 0;
+      }
+      result += value;
+      result += span.literal.text;
     }
-    return node.kind === 79 /* Identifier */ || node.kind === 208 /* PropertyAccessExpression */ && isConstantMemberAccess(node.expression) || node.kind === 209 /* ElementAccessExpression */ && isConstantMemberAccess(node.expression) && isStringLiteralLike(node.argumentExpression);
+    return result;
   }
   function checkEnumDeclaration(node) {
     addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
@@ -69118,6 +69080,9 @@ function createTypeChecker(host) {
     if (isPrivateIdentifier(node.name)) {
       error(node, Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
     }
+    if (node.initializer) {
+      checkExpression(node.initializer);
+    }
   }
   function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
     const declarations = symbol.declarations;
@@ -92357,17 +92322,19 @@ function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host)
   });
 }
 function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
+  var _a2, _b;
+  (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitUsingBuildInfo", {}, true);
+  ts_performance_exports.mark("beforeEmit");
+  const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
+  ts_performance_exports.mark("afterEmit");
+  ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
+  (_b = tracing) == null ? void 0 : _b.pop();
+  return result;
+}
+function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers) {
   const createHash = maybeBind(host, host.createHash);
   const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, false);
-  let buildInfo;
-  if (host.getBuildInfo) {
-    buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
-  } else {
-    const buildInfoText = host.readFile(buildInfoPath);
-    if (!buildInfoText)
-      return buildInfoPath;
-    buildInfo = getBuildInfo(buildInfoPath, buildInfoText);
-  }
+  const buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
   if (!buildInfo)
     return buildInfoPath;
   if (!buildInfo.bundle || !buildInfo.bundle.js || declarationFilePath && !buildInfo.bundle.dts)
@@ -92393,21 +92360,21 @@ function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
   if (declarationMapPath && computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
     return declarationMapPath;
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
-  const ownPrependInput = createInputFiles(
+  const ownPrependInput = createInputFilesWithFileTexts(
+    jsFilePath,
     jsFileText,
-    declarationText,
     sourceMapFilePath,
     sourceMapText,
+    declarationFilePath,
+    declarationText,
     declarationMapPath,
     declarationMapText,
-    jsFilePath,
-    declarationFilePath,
     buildInfoPath,
     buildInfo,
     true
   );
   const outputFiles = [];
-  const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f));
+  const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f), host);
   const sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
   let changedDtsText;
   let changedDtsData;
@@ -97058,14 +97025,12 @@ function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, ge
 function createCompilerHost(options, setParentNodes) {
   return createCompilerHostWorker(options, setParentNodes);
 }
-function createCompilerHostWorker(options, setParentNodes, system = sys) {
-  const existingDirectories = new Map();
-  const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
-  function getSourceFile(fileName, languageVersionOrOptions, onError) {
+function createGetSourceFile(readFile, getCompilerOptions, setParentNodes) {
+  return (fileName, languageVersionOrOptions, onError) => {
     let text;
     try {
       mark("beforeIORead");
-      text = compilerHost.readFile(fileName);
+      text = readFile(fileName, getCompilerOptions().charset);
       mark("afterIORead");
       measure("I/O Read", "beforeIORead", "afterIORead");
     } catch (e) {
@@ -97075,27 +97040,19 @@ function createCompilerHostWorker(options, setParentNodes, system = sys) {
       text = "";
     }
     return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : void 0;
-  }
-  function directoryExists(directoryPath) {
-    if (existingDirectories.has(directoryPath)) {
-      return true;
-    }
-    if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
-      existingDirectories.set(directoryPath, true);
-      return true;
-    }
-    return false;
-  }
-  function writeFile2(fileName, data, writeByteOrderMark, onError) {
+  };
+}
+function createWriteFileMeasuringIO(actualWriteFile, createDirectory, directoryExists) {
+  return (fileName, data, writeByteOrderMark, onError) => {
     try {
       mark("beforeIOWrite");
       writeFileEnsuringDirectories(
         fileName,
         data,
         writeByteOrderMark,
-        (path, data2, writeByteOrderMark2) => system.writeFile(path, data2, writeByteOrderMark2),
-        (path) => (compilerHost.createDirectory || system.createDirectory)(path),
-        (path) => directoryExists(path)
+        actualWriteFile,
+        createDirectory,
+        directoryExists
       );
       mark("afterIOWrite");
       measure("I/O Write", "beforeIOWrite", "afterIOWrite");
@@ -97104,6 +97061,20 @@ function createCompilerHostWorker(options, setParentNodes, system = sys) {
         onError(e.message);
       }
     }
+  };
+}
+function createCompilerHostWorker(options, setParentNodes, system = sys) {
+  const existingDirectories = new Map();
+  const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
+  function directoryExists(directoryPath) {
+    if (existingDirectories.has(directoryPath)) {
+      return true;
+    }
+    if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
+      existingDirectories.set(directoryPath, true);
+      return true;
+    }
+    return false;
   }
   function getDefaultLibLocation() {
     return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
@@ -97111,10 +97082,14 @@ function createCompilerHostWorker(options, setParentNodes, system = sys) {
   const newLine = getNewLineCharacter(options, () => system.newLine);
   const realpath = system.realpath && ((path) => system.realpath(path));
   const compilerHost = {
-    getSourceFile,
+    getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), () => options, setParentNodes),
     getDefaultLibLocation,
     getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
-    writeFile: writeFile2,
+    writeFile: createWriteFileMeasuringIO(
+      (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
+      (path) => (compilerHost.createDirectory || system.createDirectory)(path),
+      (path) => directoryExists(path)
+    ),
     getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
     useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
     getCanonicalFileName,
@@ -98458,7 +98433,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         const path = toPath3(fileName);
         const sourceFile = getSourceFileByPath(path);
         return sourceFile ? sourceFile.text : filesByName.has(path) ? void 0 : host.readFile(path);
-      }
+      },
+      host
     );
   }
   function isSourceFileFromExternalLibrary(file) {
@@ -100244,7 +100220,7 @@ function parseConfigHostFromCompilerHostLike(host, directoryStructureHost = host
     trace: host.trace ? (s) => host.trace(s) : void 0
   };
 }
-function createPrependNodes(projectReferences, getCommandLine, readFile) {
+function createPrependNodes(projectReferences, getCommandLine, readFile, host) {
   if (!projectReferences)
     return emptyArray;
   let nodes;
@@ -100256,7 +100232,7 @@ function createPrependNodes(projectReferences, getCommandLine, readFile) {
       if (!out)
         continue;
       const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(resolvedRefOpts.options, true);
-      const node = createInputFiles(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath);
+      const node = createInputFilesWithFilePaths(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
       (nodes || (nodes = [])).push(node);
     }
   }
@@ -100450,7 +100426,8 @@ var BuilderState;
   function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
     var _a2, _b, _c;
     const fileInfos = new Map();
-    const referencedMap = newProgram.getCompilerOptions().module !== 0 /* None */ ? createManyToManyPathMap() : void 0;
+    const options = newProgram.getCompilerOptions();
+    const referencedMap = options.module !== 0 /* None */ && !outFile(options) ? createManyToManyPathMap() : void 0;
     const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
     const useOldState = canReuseOldState(referencedMap, oldState);
     newProgram.getTypeChecker();
@@ -100898,7 +100875,7 @@ function getNextAffectedFilePendingEmit(state) {
     const seenEmittedFiles = state.seenEmittedFiles || (state.seenEmittedFiles = new Map());
     for (let i = state.affectedFilesPendingEmitIndex; i < affectedFilesPendingEmit.length; i++) {
       const affectedFile = Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);
-      if (affectedFile) {
+      if (affectedFile && sourceFileMayBeEmitted(affectedFile, state.program)) {
         const seenKind = seenEmittedFiles.get(affectedFile.resolvedPath);
         const emitKind = Debug.checkDefined(Debug.checkDefined(state.affectedFilesPendingEmitKind).get(affectedFile.resolvedPath));
         if (seenKind === void 0 || seenKind < emitKind) {
@@ -101203,6 +101180,9 @@ function getProgramBuildInfo(state, getCanonicalFileName) {
     const seenFiles = new Set();
     for (const path of state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(compareStringsCaseSensitive)) {
       if (tryAddToSet(seenFiles, path)) {
+        const file = state.program.getSourceFileByPath(path);
+        if (!sourceFileMayBeEmitted(file, state.program))
+          continue;
         const fileId = toFileId(path), emitKind = state.affectedFilesPendingEmitKind.get(path);
         (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(
           emitKind === 1 /* Full */ ? fileId : [fileId]
@@ -102976,24 +102956,18 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
   const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
   const hostGetNewLine = memoize(() => host.getNewLine());
   return {
-    getSourceFile: (fileName, languageVersionOrOptions, onError) => {
-      let text;
-      try {
-        mark("beforeIORead");
-        text = host.readFile(fileName, getCompilerOptions().charset);
-        mark("afterIORead");
-        measure("I/O Read", "beforeIORead", "afterIORead");
-      } catch (e) {
-        if (onError) {
-          onError(e.message);
-        }
-        text = "";
-      }
-      return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions) : void 0;
-    },
+    getSourceFile: createGetSourceFile(
+      (fileName, encoding) => host.readFile(fileName, encoding),
+      getCompilerOptions,
+      void 0
+    ),
     getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
     getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
-    writeFile: writeFile2,
+    writeFile: createWriteFileMeasuringIO(
+      (path, data, writeByteOrderMark) => host.writeFile(path, data, writeByteOrderMark),
+      (path) => host.createDirectory(path),
+      (path) => host.directoryExists(path)
+    ),
     getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
     useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
     getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames),
@@ -103010,25 +102984,6 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
     storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
   };
-  function writeFile2(fileName, text, writeByteOrderMark, onError) {
-    try {
-      mark("beforeIOWrite");
-      writeFileEnsuringDirectories(
-        fileName,
-        text,
-        writeByteOrderMark,
-        (path, data, writeByteOrderMark2) => host.writeFile(path, data, writeByteOrderMark2),
-        (path) => host.createDirectory(path),
-        (path) => host.directoryExists(path)
-      );
-      mark("afterIOWrite");
-      measure("I/O Write", "beforeIOWrite", "afterIOWrite");
-    } catch (e) {
-      if (onError) {
-        onError(e.message);
-      }
-    }
-  }
 }
 function setGetSourceFileAsHashVersioned(compilerHost, host) {
   const originalGetSourceFile = compilerHost.getSourceFile;
@@ -104489,7 +104444,7 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
     return emitDiagnostics;
   }
   function emitBundle(writeFileCallback, customTransformers) {
-    var _a2, _b;
+    var _a2, _b, _c, _d;
     Debug.assert(kind === 1 /* UpdateBundle */);
     if (state.options.dry) {
       reportStatus(state, Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
@@ -104501,6 +104456,7 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
       reportStatus(state, Diagnostics.Updating_output_of_project_0, project);
     const { compilerHost } = state;
     state.projectCompilerOptions = config.options;
+    (_b = (_a2 = state.host).beforeEmitBundle) == null ? void 0 : _b.call(_a2, config);
     const outputFiles = emitUsingBuildInfo(
       config,
       compilerHost,
@@ -104508,7 +104464,7 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
         const refName = resolveProjectName(state, ref.path);
         return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName));
       },
-      customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project))
+      customTransformers || ((_d = (_c = state.host).getCustomTransformers) == null ? void 0 : _d.call(_c, project))
     );
     if (isString(outputFiles)) {
       reportStatus(state, Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
@@ -106250,14 +106206,17 @@ function performBuild(sys2, cb, buildOptions, watchOptions, projects, errors) {
     const solutionPerformance2 = enableSolutionPerformance(sys2, buildOptions);
     updateSolutionBuilderHost(sys2, cb, buildHost2, solutionPerformance2);
     const onWatchStatusChange = buildHost2.onWatchStatusChange;
+    let reportBuildStatistics = false;
     buildHost2.onWatchStatusChange = (d, newLine, options, errorCount) => {
       onWatchStatusChange == null ? void 0 : onWatchStatusChange(d, newLine, options, errorCount);
-      if (d.code === Diagnostics.Found_0_errors_Watching_for_file_changes.code || d.code === Diagnostics.Found_1_error_Watching_for_file_changes.code) {
+      if (reportBuildStatistics && (d.code === Diagnostics.Found_0_errors_Watching_for_file_changes.code || d.code === Diagnostics.Found_1_error_Watching_for_file_changes.code)) {
         reportSolutionBuilderTimes(builder2, solutionPerformance2);
       }
     };
     const builder2 = createSolutionBuilderWithWatch(buildHost2, projects, buildOptions, watchOptions);
     builder2.build();
+    reportSolutionBuilderTimes(builder2, solutionPerformance2);
+    reportBuildStatistics = true;
     return builder2;
   }
   const buildHost = createSolutionBuilderHost(
@@ -106329,7 +106288,11 @@ function updateSolutionBuilderHost(sys2, cb, buildHost, solutionPerformance) {
     reportStatistics(sys2, program.getProgram(), solutionPerformance);
     cb(program);
   };
-  buildHost.afterEmitBundle = cb;
+  buildHost.beforeEmitBundle = (config) => enableStatisticsAndTracing(sys2, config.options, true);
+  buildHost.afterEmitBundle = (config) => {
+    reportStatistics(sys2, config, solutionPerformance);
+    cb(config);
+  };
 }
 function updateCreateProgram(sys2, host, isBuildMode) {
   const compileUsingBuilder = host.createProgram;
@@ -106434,6 +106397,7 @@ function reportSolutionBuilderTimes(builder, solutionPerformance) {
   });
   disable();
   enable();
+  solutionPerformance.clear();
   reportAllStatistics(sys, statistics);
   function reportSolutionBuilderCountStatistic(name) {
     const value = getCount(name);
@@ -106466,9 +106430,14 @@ function enableStatisticsAndTracing(system, compilerOptions, isBuildMode) {
 function isSolutionMarkOrMeasure(name) {
   return startsWith(name, "SolutionBuilder::");
 }
-function reportStatistics(sys2, program, solutionPerformance) {
+function isProgram(programOrConfig) {
+  return !programOrConfig.options;
+}
+function reportStatistics(sys2, programOrConfig, solutionPerformance) {
   var _a2;
-  const compilerOptions = program.getCompilerOptions();
+  const program = isProgram(programOrConfig) ? programOrConfig : void 0;
+  const config = isProgram(programOrConfig) ? void 0 : programOrConfig;
+  const compilerOptions = program ? program.getCompilerOptions() : config.options;
   if (canTrace(sys2, compilerOptions)) {
     (_a2 = tracing) == null ? void 0 : _a2.stopTracing();
   }
@@ -106476,19 +106445,21 @@ function reportStatistics(sys2, program, solutionPerformance) {
   if (canReportDiagnostics(sys2, compilerOptions)) {
     statistics = [];
     const memoryUsed = sys2.getMemoryUsage ? sys2.getMemoryUsage() : -1;
-    reportCountStatistic("Files", program.getSourceFiles().length);
-    const lineCounts = countLines(program);
-    if (compilerOptions.extendedDiagnostics) {
-      for (const key of arrayFrom(lineCounts.keys())) {
-        reportCountStatistic("Lines of " + key, lineCounts.get(key));
+    if (program) {
+      reportCountStatistic("Files", program.getSourceFiles().length);
+      const lineCounts = countLines(program);
+      if (compilerOptions.extendedDiagnostics) {
+        for (const key of arrayFrom(lineCounts.keys())) {
+          reportCountStatistic("Lines of " + key, lineCounts.get(key));
+        }
+      } else {
+        reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum2, count) => sum2 + count, 0));
       }
-    } else {
-      reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum2, count) => sum2 + count, 0));
+      reportCountStatistic("Identifiers", program.getIdentifierCount());
+      reportCountStatistic("Symbols", program.getSymbolCount());
+      reportCountStatistic("Types", program.getTypeCount());
+      reportCountStatistic("Instantiations", program.getInstantiationCount());
     }
-    reportCountStatistic("Identifiers", program.getIdentifierCount());
-    reportCountStatistic("Symbols", program.getSymbolCount());
-    reportCountStatistic("Types", program.getTypeCount());
-    reportCountStatistic("Instantiations", program.getInstantiationCount());
     if (memoryUsed >= 0) {
       reportStatisticalValue({ name: "Memory used", value: memoryUsed, type: 2 /* memory */ }, true);
     }
@@ -106498,11 +106469,13 @@ function reportStatistics(sys2, program, solutionPerformance) {
     const checkTime = isPerformanceEnabled ? getDuration("Check") : 0;
     const emitTime = isPerformanceEnabled ? getDuration("Emit") : 0;
     if (compilerOptions.extendedDiagnostics) {
-      const caches = program.getRelationCacheSizes();
-      reportCountStatistic("Assignability cache size", caches.assignable);
-      reportCountStatistic("Identity cache size", caches.identity);
-      reportCountStatistic("Subtype cache size", caches.subtype);
-      reportCountStatistic("Strict subtype cache size", caches.strictSubtype);
+      if (program) {
+        const caches = program.getRelationCacheSizes();
+        reportCountStatistic("Assignability cache size", caches.assignable);
+        reportCountStatistic("Identity cache size", caches.identity);
+        reportCountStatistic("Subtype cache size", caches.subtype);
+        reportCountStatistic("Strict subtype cache size", caches.strictSubtype);
+      }
       if (isPerformanceEnabled) {
         forEachMeasure((name, duration) => {
           if (!isSolutionMarkOrMeasure(name))