typescript 5.5.0-dev.20240327 → 5.5.0-dev.20240328

package/lib/typescript.js

@@ -402,6 +402,7 @@ __export(typescript_exports, {
   createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory: () => createEmitHelperFactory,
   createEmptyExports: () => createEmptyExports,
+  createEvaluator: () => createEvaluator,
   createExpressionForJsxElement: () => createExpressionForJsxElement,
   createExpressionForJsxFragment: () => createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
@@ -2327,7 +2328,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240327`;
+var version = `${versionMajorMinor}.0-dev.20240328`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6695,6 +6696,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
   ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
   ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
+  ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
   ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -21935,6 +21937,91 @@ function isSyntacticallyString(expr) {
   }
   return false;
 }
+function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
+  function evaluate(expr, location) {
+    switch (expr.kind) {
+      case 224 /* PrefixUnaryExpression */:
+        const value = evaluate(expr.operand, location);
+        if (typeof value === "number") {
+          switch (expr.operator) {
+            case 40 /* PlusToken */:
+              return value;
+            case 41 /* MinusToken */:
+              return -value;
+            case 55 /* TildeToken */:
+              return ~value;
+          }
+        }
+        break;
+      case 226 /* 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 52 /* BarToken */:
+              return left | right;
+            case 51 /* AmpersandToken */:
+              return left & right;
+            case 49 /* GreaterThanGreaterThanToken */:
+              return left >> right;
+            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
+              return left >>> right;
+            case 48 /* LessThanLessThanToken */:
+              return left << right;
+            case 53 /* CaretToken */:
+              return left ^ right;
+            case 42 /* AsteriskToken */:
+              return left * right;
+            case 44 /* SlashToken */:
+              return left / right;
+            case 40 /* PlusToken */:
+              return left + right;
+            case 41 /* MinusToken */:
+              return left - right;
+            case 45 /* PercentToken */:
+              return left % right;
+            case 43 /* AsteriskAsteriskToken */:
+              return left ** right;
+          }
+        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
+          return "" + left + right;
+        }
+        break;
+      case 11 /* StringLiteral */:
+      case 15 /* NoSubstitutionTemplateLiteral */:
+        return expr.text;
+      case 228 /* TemplateExpression */:
+        return evaluateTemplateExpression(expr, location);
+      case 9 /* NumericLiteral */:
+        return +expr.text;
+      case 217 /* ParenthesizedExpression */:
+        return evaluate(expr.expression, location);
+      case 80 /* Identifier */:
+        return evaluateEntityNameExpression(expr, location);
+      case 211 /* PropertyAccessExpression */:
+        if (isEntityNameExpression(expr)) {
+          return evaluateEntityNameExpression(expr, location);
+        }
+        break;
+      case 212 /* ElementAccessExpression */:
+        return evaluateElementAccessExpression(expr, location);
+    }
+    return void 0;
+  }
+  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 result;
+  }
+  return evaluate;
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -48134,6 +48221,10 @@ function createTypeChecker(host) {
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
   var nodeBuilder = createNodeBuilder();
+  var evaluate = createEvaluator({
+    evaluateElementAccessExpression,
+    evaluateEntityNameExpression
+  });
   var globals = createSymbolTable();
   var undefinedSymbol = createSymbol(4 /* Property */, "undefined");
   undefinedSymbol.declarations = [];
@@ -53304,7 +53395,7 @@ function createTypeChecker(host) {
         }
         const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
         if (some(abstractSignatures)) {
-          const types = map(abstractSignatures, getOrCreateTypeFromSignature);
+          const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
           const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
           // the logic in `createTypeNodesFromResolvedType`.
           (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -54619,7 +54710,7 @@ function createTypeChecker(host) {
           const type = getDeclaredTypeOfSymbol(sym);
           const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
           name.symbol = sym;
-          return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
+          return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */), node) };
         }
       }
       return { introducesError, node };
@@ -54629,7 +54720,6 @@ function createTypeChecker(host) {
         cancellationToken.throwIfCancellationRequested();
       }
       let hadError = false;
-      const file = getSourceFileOfNode(existing);
       const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
       if (hadError) {
         return void 0;
@@ -54780,8 +54870,17 @@ function createTypeChecker(host) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
-          setEmitFlags(node, 1 /* SingleLine */);
+        if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
+          const visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          const clone2 = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+          const flags = getEmitFlags(clone2);
+          setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
+          return clone2;
         }
         return visitEachChild(
           node,
@@ -59461,11 +59560,15 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type);
     return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
   }
-  function getModifiersTypeOptionality(type) {
-    return type.flags & 2097152 /* Intersection */ ? Math.max(...map(type.types, getModifiersTypeOptionality)) : getObjectFlags(type) & 32 /* Mapped */ ? getCombinedMappedTypeOptionality(type) : 0;
-  }
   function getCombinedMappedTypeOptionality(type) {
-    return getMappedTypeOptionality(type) || getModifiersTypeOptionality(getModifiersTypeFromMappedType(type));
+    if (getObjectFlags(type) & 32 /* Mapped */) {
+      return getMappedTypeOptionality(type) || getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(type));
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      const optionality = getCombinedMappedTypeOptionality(type.types[0]);
+      return every(type.types, (t, i) => i === 0 || getCombinedMappedTypeOptionality(t) === optionality) ? optionality : 0;
+    }
+    return 0;
   }
   function isPartialMappedType(type) {
     return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
@@ -60742,6 +60845,12 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
+  function getImplementationSignature(signature) {
+    return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
+  }
+  function createImplementationSignature(signature) {
+    return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
+  }
   function getBaseSignature(signature) {
     const typeParameters = signature.typeParameters;
     if (typeParameters) {
@@ -60764,12 +60873,22 @@ function createTypeChecker(host) {
     }
     return signature;
   }
-  function getOrCreateTypeFromSignature(signature) {
+  function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
     var _a;
     if (!signature.isolatedSignatureType) {
       const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
       const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
-      const type = createObjectType(16 /* Anonymous */);
+      const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
+      if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+        type.symbol.declarations = [signature.declaration];
+        type.symbol.valueDeclaration = signature.declaration;
+      }
+      outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
+        signature.declaration,
+        /*includeThisTypes*/
+        true
+      ));
+      type.outerTypeParameters = outerTypeParameters;
       type.members = emptySymbols;
       type.properties = emptyArray;
       type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -63258,13 +63377,18 @@ function createTypeChecker(host) {
     const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
     const templateMapper = combineTypeMappers(objectType.mapper, mapper);
     const instantiatedTemplateType = instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    const isOptional = getMappedTypeOptionality(objectType) > 0 || (isGenericType(objectType) ? getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(objectType)) > 0 : couldAccessOptionalProperty(objectType, index));
     return addOptionality(
       instantiatedTemplateType,
       /*isProperty*/
       true,
-      getCombinedMappedTypeOptionality(objectType) > 0
+      isOptional
     );
   }
+  function couldAccessOptionalProperty(objectType, indexType) {
+    const indexConstraint = getBaseConstraintOfType(indexType);
+    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */), indexConstraint));
+  }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
   }
@@ -64175,7 +64299,7 @@ function createTypeChecker(host) {
     const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
     const links = getNodeLinks(declaration);
     const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
-    let typeParameters = links.outerTypeParameters;
+    let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
         declaration,
@@ -64355,6 +64479,9 @@ function createTypeChecker(host) {
     if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
       result.node = type.node;
     }
+    if (type.objectFlags & 134217728 /* SingleSignatureType */) {
+      result.outerTypeParameters = type.outerTypeParameters;
+    }
     result.target = type;
     result.mapper = mapper;
     result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -68986,7 +69113,7 @@ function createTypeChecker(host) {
     if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
       return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
     }
-    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
     if (type.flags & 3899393 /* ObjectFlagsType */) {
       type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
@@ -69270,6 +69397,9 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
+  function isTupleOfSelf(typeParameter, type) {
+    return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
+  }
   function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
@@ -69355,6 +69485,9 @@ function createTypeChecker(host) {
               inference.priority = priority;
             }
             if (priority === inference.priority) {
+              if (isTupleOfSelf(inference.typeParameter, candidate)) {
+                return;
+              }
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -76293,7 +76426,7 @@ function createTypeChecker(host) {
     argument = skipParentheses(argument);
     return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
   }
-  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain) {
+  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
     if (isJsxOpeningLikeElement(node)) {
       if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
@@ -76327,7 +76460,8 @@ function createTypeChecker(host) {
           void 0,
           checkMode
         );
-        const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const regularArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const checkArgType = inferenceContext ? instantiateType(regularArgType, inferenceContext.nonFixingMapper) : regularArgType;
         const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
         if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
           Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -76739,7 +76873,9 @@ function createTypeChecker(host) {
             0 /* Normal */,
             /*reportErrors*/
             true,
-            () => chain
+            () => chain,
+            /*inferenceContext*/
+            void 0
           );
           if (diags) {
             for (const d of diags) {
@@ -76775,7 +76911,9 @@ function createTypeChecker(host) {
               0 /* Normal */,
               /*reportErrors*/
               true,
-              chain2
+              chain2,
+              /*inferenceContext*/
+              void 0
             );
             if (diags2) {
               if (diags2.length <= min2) {
@@ -76866,6 +77004,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
+          void 0,
+          /*inferenceContext*/
           void 0
         )) {
           candidatesForArgumentError = [candidate];
@@ -76874,13 +77014,16 @@ function createTypeChecker(host) {
         return candidate;
       }
       for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
-        const candidate = candidates2[candidateIndex];
+        let candidate = candidates2[candidateIndex];
         if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           continue;
         }
         let checkCandidate;
         let inferenceContext;
         if (candidate.typeParameters) {
+          if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
+            candidate = getImplementationSignature(candidate);
+          }
           let typeArgumentTypes;
           if (some(typeArguments)) {
             typeArgumentTypes = checkTypeArguments(
@@ -76900,7 +77043,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+            typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
             argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
           }
           checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -76920,7 +77063,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
-          void 0
+          void 0,
+          inferenceContext
         )) {
           (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
           continue;
@@ -76928,7 +77072,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = 0 /* Normal */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+            const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
@@ -76944,7 +77088,8 @@ function createTypeChecker(host) {
             /*reportErrors*/
             false,
             /*containingMessageChain*/
-            void 0
+            void 0,
+            inferenceContext
           )) {
             (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
             continue;
@@ -80484,7 +80629,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node);
     return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
@@ -80698,7 +80843,7 @@ function createTypeChecker(host) {
                 }
               }
             }
-            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
           }
         }
       }
@@ -80873,7 +81018,8 @@ function createTypeChecker(host) {
     if (getIsolatedModules(compilerOptions)) {
       Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
       const constEnumDeclaration = type.symbol.valueDeclaration;
-      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node)) {
+      const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
+      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node) && (!redirect || !shouldPreserveConstEnums(redirect.commandLine.options))) {
         error2(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
       }
     }
@@ -85460,122 +85606,53 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function evaluate(expr, location) {
-    switch (expr.kind) {
-      case 224 /* PrefixUnaryExpression */:
-        const value = evaluate(expr.operand, location);
-        if (typeof value === "number") {
-          switch (expr.operator) {
-            case 40 /* PlusToken */:
-              return value;
-            case 41 /* MinusToken */:
-              return -value;
-            case 55 /* TildeToken */:
-              return ~value;
-          }
-        }
-        break;
-      case 226 /* 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 52 /* BarToken */:
-              return left | right;
-            case 51 /* AmpersandToken */:
-              return left & right;
-            case 49 /* GreaterThanGreaterThanToken */:
-              return left >> right;
-            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
-              return left >>> right;
-            case 48 /* LessThanLessThanToken */:
-              return left << right;
-            case 53 /* CaretToken */:
-              return left ^ right;
-            case 42 /* AsteriskToken */:
-              return left * right;
-            case 44 /* SlashToken */:
-              return left / right;
-            case 40 /* PlusToken */:
-              return left + right;
-            case 41 /* MinusToken */:
-              return left - right;
-            case 45 /* PercentToken */:
-              return left % right;
-            case 43 /* AsteriskAsteriskToken */:
-              return left ** right;
-          }
-        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
-          return "" + left + right;
-        }
-        break;
-      case 11 /* StringLiteral */:
-      case 15 /* NoSubstitutionTemplateLiteral */:
-        return expr.text;
-      case 228 /* TemplateExpression */:
-        return evaluateTemplateExpression(expr, location);
-      case 9 /* NumericLiteral */:
-        checkGrammarNumericLiteral(expr);
-        return +expr.text;
-      case 217 /* ParenthesizedExpression */:
-        return evaluate(expr.expression, location);
-      case 80 /* Identifier */: {
-        const identifier = expr;
-        if (isInfinityOrNaNString(identifier.escapedText) && resolveEntityName(
-          identifier,
-          111551 /* Value */,
-          /*ignoreErrors*/
-          true
-        ) === getGlobalSymbol(
-          identifier.escapedText,
-          111551 /* Value */,
-          /*diagnostic*/
-          void 0
-        )) {
-          return +identifier.escapedText;
-        }
+  function evaluateEntityNameExpression(expr, location) {
+    const symbol = resolveEntityName(
+      expr,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    );
+    if (!symbol)
+      return void 0;
+    if (expr.kind === 80 /* Identifier */) {
+      const identifier = expr;
+      if (isInfinityOrNaNString(identifier.escapedText) && symbol === getGlobalSymbol(
+        identifier.escapedText,
+        111551 /* Value */,
+        /*diagnostic*/
+        void 0
+      )) {
+        return +identifier.escapedText;
       }
-      case 211 /* PropertyAccessExpression */:
-        if (isEntityNameExpression(expr)) {
-          const symbol = resolveEntityName(
-            expr,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (symbol) {
-            if (symbol.flags & 8 /* EnumMember */) {
-              return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
-            }
-            if (isConstantVariable(symbol)) {
-              const declaration = symbol.valueDeclaration;
-              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-                return evaluate(declaration.initializer, declaration);
-              }
-            }
-          }
-        }
-        break;
-      case 212 /* ElementAccessExpression */:
-        const root = expr.expression;
-        if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
-          const rootSymbol = resolveEntityName(
-            root,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
-            const name = escapeLeadingUnderscores(expr.argumentExpression.text);
-            const member = rootSymbol.exports.get(name);
-            if (member) {
-              return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
-            }
-          }
+    }
+    if (symbol.flags & 8 /* EnumMember */) {
+      return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
+    }
+    if (isConstantVariable(symbol)) {
+      const declaration = symbol.valueDeclaration;
+      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
+        return evaluate(declaration.initializer, declaration);
+      }
+    }
+  }
+  function evaluateElementAccessExpression(expr, location) {
+    const root = expr.expression;
+    if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+      const rootSymbol = resolveEntityName(
+        root,
+        111551 /* Value */,
+        /*ignoreErrors*/
+        true
+      );
+      if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
+        const name = escapeLeadingUnderscores(expr.argumentExpression.text);
+        const member = rootSymbol.exports.get(name);
+        if (member) {
+          return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
         }
-        break;
+      }
     }
-    return void 0;
   }
   function evaluateEnumMember(expr, symbol, location) {
     const declaration = symbol.valueDeclaration;
@@ -85589,18 +85666,6 @@ function createTypeChecker(host) {
     }
     return getEnumMemberValue(declaration);
   }
-  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 result;
-  }
   function checkEnumDeclaration(node) {
     addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
   }
@@ -122023,6 +122088,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     getResolvedProjectReferenceByPath,
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
+    getRedirectReferenceForResolutionFromSourceOfProject,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -159431,7 +159497,8 @@ function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, con
   }
   function symbolAppearsToBeTypeOnly(symbol) {
     var _a;
-    return !(symbol.flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(symbol.flags & 788968 /* Type */));
+    const flags = getCombinedLocalAndExportSymbolFlags(skipAlias(symbol, typeChecker));
+    return !(flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(flags & 788968 /* Type */));
   }
 }
 function getLabelCompletionAtPosition(node) {
@@ -173851,6 +173918,7 @@ __export(ts_exports2, {
   createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory: () => createEmitHelperFactory,
   createEmptyExports: () => createEmptyExports,
+  createEvaluator: () => createEvaluator,
   createExpressionForJsxElement: () => createExpressionForJsxElement,
   createExpressionForJsxFragment: () => createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
@@ -180069,7 +180137,16 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       recursive ? watchedDirectoriesRecursive : watchedDirectories,
       path,
       callback,
-      (id) => ({ eventName: CreateDirectoryWatcherEvent, data: { id, path, recursive: !!recursive } })
+      (id) => ({
+        eventName: CreateDirectoryWatcherEvent,
+        data: {
+          id,
+          path,
+          recursive: !!recursive,
+          // Special case node_modules as we watch it for changes to closed script infos as well
+          ignoreUpdate: !path.endsWith("/node_modules") ? true : void 0
+        }
+      })
     );
   }
   function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path, callback, event) {
@@ -180096,24 +180173,28 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       }
     };
   }
-  function onWatchChange({ id, path, eventType }) {
-    onFileWatcherCallback(id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectories, id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectoriesRecursive, id, path, eventType);
+  function onWatchChange(args) {
+    if (isArray(args))
+      args.forEach(onWatchChangeRequestArgs);
+    else
+      onWatchChangeRequestArgs(args);
   }
-  function onFileWatcherCallback(id, eventPath, eventType) {
-    var _a;
-    (_a = watchedFiles.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      const eventKind = eventType === "create" ? 0 /* Created */ : eventType === "delete" ? 2 /* Deleted */ : 1 /* Changed */;
-      callback(eventPath, eventKind);
-    });
+  function onWatchChangeRequestArgs({ id, created, deleted, updated }) {
+    onWatchEventType(id, created, 0 /* Created */);
+    onWatchEventType(id, deleted, 2 /* Deleted */);
+    onWatchEventType(id, updated, 1 /* Changed */);
   }
-  function onDirectoryWatcherCallback({ idToCallbacks }, id, eventPath, eventType) {
-    var _a;
-    if (eventType === "update")
+  function onWatchEventType(id, paths, eventKind) {
+    if (!(paths == null ? void 0 : paths.length))
       return;
-    (_a = idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      callback(eventPath);
+    forEachCallback(watchedFiles, id, paths, (callback, eventPath) => callback(eventPath, eventKind));
+    forEachCallback(watchedDirectories, id, paths, (callback, eventPath) => callback(eventPath));
+    forEachCallback(watchedDirectoriesRecursive, id, paths, (callback, eventPath) => callback(eventPath));
+  }
+  function forEachCallback(hostWatcherMap, id, eventPaths, cb) {
+    var _a;
+    (_a = hostWatcherMap.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
+      eventPaths.forEach((eventPath) => cb(callback, normalizeSlashes(eventPath)));
     });
   }
 }
@@ -183086,7 +183167,6 @@ Dynamic files must always be opened with service's current directory or service
         (fileName, eventKind) => {
           switch (eventKind) {
             case 0 /* Created */:
-              return Debug.fail();
             case 1 /* Changed */:
               this.packageJsonCache.addOrUpdate(fileName, path);
               this.onPackageJsonChange(result);
@@ -188054,6 +188134,7 @@ if (typeof console !== "undefined") {
   createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory,
   createEmptyExports,
+  createEvaluator,
   createExpressionForJsxElement,
   createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike,