@typescript-deploys/pr-build 5.3.0-pr-55452-4 → 5.3.0-pr-55459-3

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-insiders.20230821`;
+      version = `${versionMajorMinor}.0-insiders.20230822`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -19303,9 +19303,6 @@ ${lanes.join("\n")}
     }
     return Debug.fail();
   }
-  function isNamedTupleMemberName(node) {
-    return node.kind === 80 /* Identifier */ || node.kind === 203 /* TemplateLiteralType */ || node.kind === 15 /* NoSubstitutionTemplateLiteral */;
-  }
   var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
@@ -31129,29 +31126,21 @@ ${lanes.join("\n")}
           }
           return type;
         }
-        function isTokenColonOrQuestionColon() {
-          return token() === 59 /* ColonToken */ || token() === 58 /* QuestionToken */ && nextToken() === 59 /* ColonToken */;
+        function isNextTokenColonOrQuestionColon() {
+          return nextToken() === 59 /* ColonToken */ || token() === 58 /* QuestionToken */ && nextToken() === 59 /* ColonToken */;
         }
         function isTupleElementName() {
           if (token() === 26 /* DotDotDotToken */) {
-            nextToken();
-          }
-          if (token() === 16 /* TemplateHead */) {
-            parseTemplateType();
-            return isTokenColonOrQuestionColon();
-          }
-          if (tokenIsIdentifierOrKeyword(token()) || token() === 15 /* NoSubstitutionTemplateLiteral */) {
-            nextToken();
-            return isTokenColonOrQuestionColon();
+            return tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
           }
-          return false;
+          return tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
         }
         function parseTupleElementNameOrTupleElementType() {
           if (lookAhead(isTupleElementName)) {
             const pos = getNodePos();
             const hasJSDoc = hasPrecedingJSDocComment();
             const dotDotDotToken = parseOptionalToken(26 /* DotDotDotToken */);
-            const name = token() === 15 /* NoSubstitutionTemplateLiteral */ ? parseLiteralLikeNode(token()) : token() === 16 /* TemplateHead */ ? parseTemplateType() : parseIdentifierName();
+            const name = parseIdentifierName();
             const questionToken = parseOptionalToken(58 /* QuestionToken */);
             parseExpected(59 /* ColonToken */);
             const type = parseTupleElementType();
@@ -50561,11 +50550,10 @@ ${lanes.join("\n")}
                 for (let i = 0; i < tupleConstituentNodes.length; i++) {
                   const flags = type2.target.elementFlags[i];
                   const labeledElementDeclaration = labeledElementDeclarations == null ? void 0 : labeledElementDeclarations[i];
-                  const label = labeledElementDeclaration && getTupleElementLabel(type2, labeledElementDeclaration);
-                  if (label) {
+                  if (labeledElementDeclaration) {
                     tupleConstituentNodes[i] = factory.createNamedTupleMember(
                       flags & 12 /* Variable */ ? factory.createToken(26 /* DotDotDotToken */) : void 0,
-                      factory.createIdentifier(unescapeLeadingUnderscores(label)),
+                      factory.createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel(labeledElementDeclaration))),
                       flags & 2 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                       flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]
                     );
@@ -53893,7 +53881,7 @@ ${lanes.join("\n")}
       const pattern = declaration.parent;
       if (strictNullChecks && declaration.flags & 33554432 /* Ambient */ && isParameterDeclaration(declaration)) {
         parentType = getNonNullableType(parentType);
-      } else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* EQUndefined */)) {
+      } else if (strictNullChecks && pattern.parent.initializer && !hasTypeFacts(getTypeOfInitializer(pattern.parent.initializer), 65536 /* EQUndefined */)) {
         parentType = getTypeWithFacts(parentType, 524288 /* NEUndefined */);
       }
       let type;
@@ -53936,7 +53924,7 @@ ${lanes.join("\n")}
         return type;
       }
       if (getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration))) {
-        return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
+        return strictNullChecks && !hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
       }
       return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
     }
@@ -55765,7 +55753,7 @@ ${lanes.join("\n")}
       function getUniqAssociatedNamesFromTupleType(type, restName) {
         const associatedNamesMap = /* @__PURE__ */ new Map();
         return map(type.target.labeledElementDeclarations, (labeledElement, i) => {
-          const name = getTupleElementLabel(type, labeledElement, i, restName);
+          const name = getTupleElementLabel(labeledElement, i, restName);
           const prevCounter = associatedNamesMap.get(name);
           if (prevCounter === void 0) {
             associatedNamesMap.set(name, 1);
@@ -57221,7 +57209,7 @@ ${lanes.join("\n")}
       }
       const iife = getImmediatelyInvokedFunctionExpression(node.parent);
       if (iife) {
-        return !node.type && !node.dotDotDotToken && node.parent.parameters.indexOf(node) >= iife.arguments.length;
+        return !node.type && !node.dotDotDotToken && node.parent.parameters.indexOf(node) >= getEffectiveCallArguments(iife).length;
       }
       return false;
     }
@@ -62044,7 +62032,7 @@ ${lanes.join("\n")}
         if (sourceType && targetType) {
           const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
           const targetSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
-          const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
+          const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && getOnlyTypeFacts(sourceType, 50331648 /* IsUndefinedOrNull */) === getOnlyTypeFacts(targetType, 50331648 /* IsUndefinedOrNull */);
           let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(
             sourceType,
             targetType,
@@ -65201,7 +65189,7 @@ ${lanes.join("\n")}
       return value.base10Value === "0";
     }
     function removeDefinitelyFalsyTypes(type) {
-      return filterType(type, (t) => !!(getTypeFacts(t) & 4194304 /* Truthy */));
+      return filterType(type, (t) => hasTypeFacts(t, 4194304 /* Truthy */));
     }
     function extractDefinitelyFalsyTypes(type) {
       return mapType(type, getDefinitelyFalsyPartOfType);
@@ -66944,7 +66932,13 @@ ${lanes.join("\n")}
       const resolved = resolveStructuredTypeMembers(type);
       return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
     }
-    function getTypeFacts(type) {
+    function getOnlyTypeFacts(type, mask2) {
+      return getTypeFactsWorker(type, mask2) & mask2;
+    }
+    function hasTypeFacts(type, mask2) {
+      return getOnlyTypeFacts(type, mask2) !== 0;
+    }
+    function getTypeFactsWorker(type, callerOnlyNeeds) {
       if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
         type = getBaseConstraintOfType(type) || unknownType;
       }
@@ -66977,6 +66971,10 @@ ${lanes.join("\n")}
         return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
       }
       if (flags & 524288 /* Object */) {
+        const possibleFacts = strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ | 7880640 /* FunctionStrictFacts */ | 7888800 /* ObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ | 16728e3 /* FunctionFacts */ | 16736160 /* ObjectFacts */;
+        if ((callerOnlyNeeds & possibleFacts) === 0) {
+          return 0;
+        }
         return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
       }
       if (flags & 16384 /* Void */) {
@@ -66998,20 +66996,20 @@ ${lanes.join("\n")}
         return 0 /* None */;
       }
       if (flags & 1048576 /* Union */) {
-        return reduceLeft(type.types, (facts, t) => facts | getTypeFacts(t), 0 /* None */);
+        return reduceLeft(type.types, (facts, t) => facts | getTypeFactsWorker(t, callerOnlyNeeds), 0 /* None */);
       }
       if (flags & 2097152 /* Intersection */) {
-        return getIntersectionTypeFacts(type);
+        return getIntersectionTypeFacts(type, callerOnlyNeeds);
       }
       return 83886079 /* UnknownFacts */;
     }
-    function getIntersectionTypeFacts(type) {
+    function getIntersectionTypeFacts(type, callerOnlyNeeds) {
       const ignoreObjects = maybeTypeOfKind(type, 402784252 /* Primitive */);
       let oredFacts = 0 /* None */;
       let andedFacts = 134217727 /* All */;
       for (const t of type.types) {
         if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
-          const f = getTypeFacts(t);
+          const f = getTypeFactsWorker(t, callerOnlyNeeds);
           oredFacts |= f;
           andedFacts &= f;
         }
@@ -67019,19 +67017,19 @@ ${lanes.join("\n")}
       return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
     }
     function getTypeWithFacts(type, include) {
-      return filterType(type, (t) => (getTypeFacts(t) & include) !== 0);
+      return filterType(type, (t) => hasTypeFacts(t, include));
     }
     function getAdjustedTypeWithFacts(type, facts) {
       const reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
       if (strictNullChecks) {
         switch (facts) {
           case 524288 /* NEUndefined */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 65536 /* EQUndefined */) ? getIntersectionType([t, hasTypeFacts(t, 131072 /* EQNull */) && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
           case 1048576 /* NENull */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 131072 /* EQNull */) ? getIntersectionType([t, hasTypeFacts(t, 65536 /* EQUndefined */) && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
           case 2097152 /* NEUndefinedOrNull */:
           case 4194304 /* Truthy */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 262144 /* EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(t) : t);
         }
       }
       return reduced;
@@ -68368,14 +68366,14 @@ ${lanes.join("\n")}
           // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
           // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
           // but are classified as "function" according to `typeof`.
-          isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
+          isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? hasTypeFacts(t, facts) ? t : neverType : (
             // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
             // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
             isTypeSubtypeOf(impliedType, t) ? impliedType : (
               // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
               // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
               // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-              getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+              hasTypeFacts(t, facts) ? getIntersectionType([t, impliedType]) : neverType
             )
           )
         ));
@@ -68389,7 +68387,7 @@ ${lanes.join("\n")}
         const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
         if (hasDefaultClause) {
           const notEqualFacts = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
-          return filterType(type, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
+          return filterType(type, (t) => getOnlyTypeFacts(t, notEqualFacts) === notEqualFacts);
         }
         const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
         return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
@@ -68527,7 +68525,7 @@ ${lanes.join("\n")}
                 false
               );
             }
-            if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
+            if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !hasTypeFacts(predicate.type, 65536 /* EQUndefined */)) {
               type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
             }
             const access = getDiscriminantPropertyAccess(predicateArgument, type);
@@ -68661,7 +68659,7 @@ ${lanes.join("\n")}
           reportCircularityError(declaration.symbol);
           return true;
         }
-        const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
+        const containsUndefined = !!hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */);
         if (!popTypeResolution()) {
           reportCircularityError(declaration.symbol);
           return true;
@@ -68671,7 +68669,7 @@ ${lanes.join("\n")}
       return links.parameterInitializerContainsUndefined;
     }
     function removeOptionalityFromDeclaredType(declaredType, declaration) {
-      const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
+      const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && hasTypeFacts(declaredType, 16777216 /* IsUndefined */) && !parameterInitializerContainsUndefined(declaration);
       return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
     }
     function isConstraintPosition(type, node) {
@@ -71501,7 +71499,7 @@ ${lanes.join("\n")}
       return checkNonNullType(checkExpression(node), node);
     }
     function isNullableType(type) {
-      return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
+      return hasTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
     }
     function getNonNullableTypeIfNeeded(type) {
       return isNullableType(type) ? getNonNullableType(type) : type;
@@ -71547,7 +71545,7 @@ ${lanes.join("\n")}
         error2(node, Diagnostics.Object_is_of_type_unknown);
         return errorType;
       }
-      const facts = getTypeFacts(type);
+      const facts = getOnlyTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
       if (facts & 50331648 /* IsUndefinedOrNull */) {
         reportError(node, facts);
         const t = getNonNullableType(type);
@@ -74521,27 +74519,20 @@ ${lanes.join("\n")}
       return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
     }
     function getTypeOfParameter(symbol) {
-      const type = getTypeOfSymbol(symbol);
-      if (strictNullChecks) {
-        const declaration = symbol.valueDeclaration;
-        if (declaration && hasInitializer(declaration)) {
-          return getOptionalType(type);
-        }
-      }
-      return type;
+      const declaration = symbol.valueDeclaration;
+      return addOptionality(
+        getTypeOfSymbol(symbol),
+        /*isProperty*/
+        false,
+        /*isOptional*/
+        !!declaration && (hasInitializer(declaration) || isOptionalDeclaration(declaration))
+      );
     }
-    function getTupleElementLabel(tupleType, d, index, restParameterName = "arg") {
+    function getTupleElementLabel(d, index, restParameterName = "arg") {
       if (!d) {
         return `${restParameterName}_${index}`;
       }
-      Debug.assert(!isBindingPattern(d.name));
-      if (d.name.kind === 203 /* TemplateLiteralType */) {
-        const label = instantiateType(getTypeFromTypeNode(d.name), tupleType.mapper);
-        return label.flags & 128 /* StringLiteral */ ? escapeLeadingUnderscores(label.value) : typeof index === "number" ? `${restParameterName}_${index}` : void 0;
-      }
-      if (d.name.kind === 15 /* NoSubstitutionTemplateLiteral */) {
-        return escapeLeadingUnderscores(d.name.text);
-      }
+      Debug.assert(isIdentifier(d.name));
       return d.name.escapedText;
     }
     function getParameterNameAtPosition(signature, pos, overrideRestType) {
@@ -74554,7 +74545,7 @@ ${lanes.join("\n")}
       if (isTupleType(restType)) {
         const associatedNames = restType.target.labeledElementDeclarations;
         const index = pos - paramCount;
-        return getTupleElementLabel(restType, associatedNames == null ? void 0 : associatedNames[index], index, restParameter.escapedName);
+        return getTupleElementLabel(associatedNames == null ? void 0 : associatedNames[index], index, restParameter.escapedName);
       }
       return restParameter.escapedName;
     }
@@ -74584,7 +74575,8 @@ ${lanes.join("\n")}
         const index = pos - paramCount;
         const associatedName = associatedNames == null ? void 0 : associatedNames[index];
         const isRestTupleElement = !!(associatedName == null ? void 0 : associatedName.dotDotDotToken);
-        if (associatedName && isIdentifier(associatedName.name)) {
+        if (associatedName) {
+          Debug.assert(isIdentifier(associatedName.name));
           return { parameter: associatedName.name, parameterName: associatedName.name.escapedText, isRestParameter: isRestTupleElement };
         }
         return void 0;
@@ -74801,23 +74793,29 @@ ${lanes.join("\n")}
         assignParameterType(parameter);
       }
     }
-    function assignParameterType(parameter, type) {
+    function assignParameterType(parameter, contextualType) {
       const links = getSymbolLinks(parameter);
       if (!links.type) {
         const declaration = parameter.valueDeclaration;
-        links.type = type || (declaration ? getWidenedTypeForVariableLikeDeclaration(
-          declaration,
-          /*reportErrors*/
-          true
-        ) : getTypeOfSymbol(parameter));
+        links.type = addOptionality(
+          contextualType || (declaration ? getWidenedTypeForVariableLikeDeclaration(
+            declaration,
+            /*reportErrors*/
+            true
+          ) : getTypeOfSymbol(parameter)),
+          /*isProperty*/
+          false,
+          /*isOptional*/
+          !!declaration && !declaration.initializer && isOptionalDeclaration(declaration)
+        );
         if (declaration && declaration.name.kind !== 80 /* Identifier */) {
           if (links.type === unknownType) {
             links.type = getTypeFromBindingPattern(declaration.name);
           }
           assignBindingElementTypes(declaration.name, links.type);
         }
-      } else if (type) {
-        Debug.assertEqual(links.type, type, "Parameter symbol already has a cached type which differs from newly assigned type");
+      } else if (contextualType) {
+        Debug.assertEqual(links.type, contextualType, "Parameter symbol already has a cached type which differs from newly assigned type");
       }
     }
     function assignBindingElementTypes(pattern, parentType) {
@@ -75327,7 +75325,7 @@ ${lanes.join("\n")}
         if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
           return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
         }
-        return !someType(operandConstraint, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
+        return !someType(operandConstraint, (t) => getOnlyTypeFacts(t, notEqualFacts) === notEqualFacts);
       }
       const type = checkExpressionCached(node.expression);
       if (!isLiteralType(type)) {
@@ -75652,7 +75650,7 @@ ${lanes.join("\n")}
     }
     function checkDeleteExpressionMustBeOptional(expr, symbol) {
       const type = getTypeOfSymbol(symbol);
-      if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
+      if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : hasTypeFacts(type, 16777216 /* IsUndefined */))) {
         error2(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
       }
     }
@@ -75787,7 +75785,7 @@ ${lanes.join("\n")}
           return getUnaryResultType(operandType);
         case 54 /* ExclamationToken */:
           checkTruthinessOfType(operandType, node.operand);
-          const facts = getTypeFacts(operandType) & (4194304 /* Truthy */ | 8388608 /* Falsy */);
+          const facts = getOnlyTypeFacts(operandType, 4194304 /* Truthy */ | 8388608 /* Falsy */);
           return facts === 4194304 /* Truthy */ ? falseType : facts === 8388608 /* Falsy */ ? trueType : booleanType;
         case 46 /* PlusPlusToken */:
         case 47 /* MinusMinusToken */:
@@ -76018,7 +76016,7 @@ ${lanes.join("\n")}
       if (exprOrAssignment.kind === 304 /* ShorthandPropertyAssignment */) {
         const prop = exprOrAssignment;
         if (prop.objectAssignmentInitializer) {
-          if (strictNullChecks && !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
+          if (strictNullChecks && !hasTypeFacts(checkExpression(prop.objectAssignmentInitializer), 16777216 /* IsUndefined */)) {
             sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
           }
           checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
@@ -76430,7 +76428,7 @@ ${lanes.join("\n")}
           return checkInExpression(left, right, leftType, rightType);
         case 56 /* AmpersandAmpersandToken */:
         case 77 /* AmpersandAmpersandEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 4194304 /* Truthy */ ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 4194304 /* Truthy */) ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
           if (operator === 77 /* AmpersandAmpersandEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -76438,7 +76436,7 @@ ${lanes.join("\n")}
         }
         case 57 /* BarBarToken */:
         case 76 /* BarBarEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 8388608 /* Falsy */ ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 8388608 /* Falsy */) ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
           if (operator === 76 /* BarBarEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -76446,7 +76444,7 @@ ${lanes.join("\n")}
         }
         case 61 /* QuestionQuestionToken */:
         case 78 /* QuestionQuestionEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 262144 /* EQUndefinedOrNull */ ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 262144 /* EQUndefinedOrNull */) ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
           if (operator === 78 /* QuestionQuestionEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -78082,9 +78080,6 @@ ${lanes.join("\n")}
       if (node.type.kind === 191 /* RestType */) {
         grammarErrorOnNode(node.type, Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type);
       }
-      if (node.name.kind === 203 /* TemplateLiteralType */) {
-        checkSourceElement(node.name);
-      }
       checkSourceElement(node.type);
       getTypeFromTypeNode(node);
     }
@@ -79766,7 +79761,7 @@ ${lanes.join("\n")}
         }
         const type = location === condExpr2 ? condType : checkTruthinessExpression(location);
         const isPropertyExpressionCast = isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
-        if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
+        if (!hasTypeFacts(type, 4194304 /* Truthy */) || isPropertyExpressionCast)
           return;
         const callSignatures = getSignaturesOfType(type, 0 /* Call */);
         const isPromise = !!getAwaitedTypeOfPromise(type);
@@ -87039,7 +87034,7 @@ ${lanes.join("\n")}
           return context.factory.updateNamedTupleMember(
             node,
             tokenVisitor ? nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken) : node.dotDotDotToken,
-            Debug.checkDefined(nodeVisitor(node.name, visitor, isNamedTupleMemberName)),
+            Debug.checkDefined(nodeVisitor(node.name, visitor, isIdentifier)),
             tokenVisitor ? nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken) : node.questionToken,
             Debug.checkDefined(nodeVisitor(node.type, visitor, isTypeNode))
           );
@@ -184649,7 +184644,6 @@ ${e.message}`;
     isNamedImports: () => isNamedImports,
     isNamedImportsOrExports: () => isNamedImportsOrExports,
     isNamedTupleMember: () => isNamedTupleMember,
-    isNamedTupleMemberName: () => isNamedTupleMemberName,
     isNamespaceBody: () => isNamespaceBody,
     isNamespaceExport: () => isNamespaceExport,
     isNamespaceExportDeclaration: () => isNamespaceExportDeclaration,
@@ -187059,7 +187053,6 @@ ${e.message}`;
     isNamedImports: () => isNamedImports,
     isNamedImportsOrExports: () => isNamedImportsOrExports,
     isNamedTupleMember: () => isNamedTupleMember,
-    isNamedTupleMemberName: () => isNamedTupleMemberName,
     isNamespaceBody: () => isNamespaceBody,
     isNamespaceExport: () => isNamespaceExport,
     isNamespaceExportDeclaration: () => isNamespaceExportDeclaration,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20230821`;
+var version = `${versionMajorMinor}.0-insiders.20230822`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -11742,9 +11742,6 @@ function getEscapedTextOfJsxNamespacedName(node) {
 function getTextOfJsxNamespacedName(node) {
   return `${idText(node.namespace)}:${idText(node.name)}`;
 }
-function isNamedTupleMemberName(node) {
-  return node.kind === 80 /* Identifier */ || node.kind === 203 /* TemplateLiteralType */ || node.kind === 15 /* NoSubstitutionTemplateLiteral */;
-}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -20517,29 +20514,21 @@ var Parser;
     }
     return type;
   }
-  function isTokenColonOrQuestionColon() {
-    return token() === 59 /* ColonToken */ || token() === 58 /* QuestionToken */ && nextToken() === 59 /* ColonToken */;
+  function isNextTokenColonOrQuestionColon() {
+    return nextToken() === 59 /* ColonToken */ || token() === 58 /* QuestionToken */ && nextToken() === 59 /* ColonToken */;
   }
   function isTupleElementName() {
     if (token() === 26 /* DotDotDotToken */) {
-      nextToken();
-    }
-    if (token() === 16 /* TemplateHead */) {
-      parseTemplateType();
-      return isTokenColonOrQuestionColon();
-    }
-    if (tokenIsIdentifierOrKeyword(token()) || token() === 15 /* NoSubstitutionTemplateLiteral */) {
-      nextToken();
-      return isTokenColonOrQuestionColon();
+      return tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
     }
-    return false;
+    return tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
   }
   function parseTupleElementNameOrTupleElementType() {
     if (lookAhead(isTupleElementName)) {
       const pos = getNodePos();
       const hasJSDoc = hasPrecedingJSDocComment();
       const dotDotDotToken = parseOptionalToken(26 /* DotDotDotToken */);
-      const name = token() === 15 /* NoSubstitutionTemplateLiteral */ ? parseLiteralLikeNode(token()) : token() === 16 /* TemplateHead */ ? parseTemplateType() : parseIdentifierName();
+      const name = parseIdentifierName();
       const questionToken = parseOptionalToken(58 /* QuestionToken */);
       parseExpected(59 /* ColonToken */);
       const type = parseTupleElementType();
@@ -29692,7 +29681,7 @@ var visitEachChildTable = {
     return context.factory.updateNamedTupleMember(
       node,
       tokenVisitor ? nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken) : node.dotDotDotToken,
-      Debug.checkDefined(nodeVisitor(node.name, visitor, isNamedTupleMemberName)),
+      Debug.checkDefined(nodeVisitor(node.name, visitor, isIdentifier)),
       tokenVisitor ? nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken) : node.questionToken,
       Debug.checkDefined(nodeVisitor(node.type, visitor, isTypeNode))
     );

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.3.0-pr-55452-4",
+  "version": "5.3.0-pr-55459-3",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -116,5 +116,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "58d231b23ea90cb6256dc152cc6c4efcb41fc2af"
+  "gitHead": "b0d71ce9f63cc73c46d03076e74a95943720149b"
 }