@typescript-deploys/pr-build 5.0.0-pr-52807-23 → 5.0.0-pr-50431-13

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230216`;
+var version = `${versionMajorMinor}.0-insiders.20230217`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -15652,20 +15652,36 @@ function isWriteOnlyAccess(node) {
 function isWriteAccess(node) {
   return accessKind(node) !== 0 /* Read */;
 }
+function isWriteOnlyUsage(node) {
+  return accessKindForUsageChecks(node) === 1 /* Write */;
+}
+function accessKindForUsageChecks(node) {
+  const kind = accessKind(node);
+  const { parent } = node;
+  switch (parent == null ? void 0 : parent.kind) {
+    case 222 /* PostfixUnaryExpression */:
+    case 221 /* PrefixUnaryExpression */:
+    case 223 /* BinaryExpression */:
+      return kind === 2 /* ReadWrite */ ? writeOrReadWrite() : kind;
+    default:
+      return kind;
+  }
+  function writeOrReadWrite() {
+    return parent.parent && walkUpParenthesizedExpressions(parent.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
+  }
+}
 function accessKind(node) {
   const { parent } = node;
-  if (!parent)
-    return 0 /* Read */;
-  switch (parent.kind) {
+  switch (parent == null ? void 0 : parent.kind) {
     case 214 /* ParenthesizedExpression */:
       return accessKind(parent);
     case 222 /* PostfixUnaryExpression */:
     case 221 /* PrefixUnaryExpression */:
       const { operator } = parent;
-      return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? writeOrReadWrite() : 0 /* Read */;
+      return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? 2 /* ReadWrite */ : 0 /* Read */;
     case 223 /* BinaryExpression */:
       const { left, operatorToken } = parent;
-      return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : writeOrReadWrite() : 0 /* Read */;
+      return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : 2 /* ReadWrite */ : 0 /* Read */;
     case 208 /* PropertyAccessExpression */:
       return parent.name !== node ? 0 /* Read */ : accessKind(parent);
     case 299 /* PropertyAssignment */: {
@@ -15679,9 +15695,6 @@ function accessKind(node) {
     default:
       return 0 /* Read */;
   }
-  function writeOrReadWrite() {
-    return parent.parent && walkUpParenthesizedExpressions(parent.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
-  }
 }
 function reverseAccessKind(a) {
   switch (a) {
@@ -24988,7 +25001,7 @@ function canHaveIllegalDecorators(node) {
 }
 function canHaveIllegalModifiers(node) {
   const kind = node.kind;
-  return kind === 172 /* ClassStaticBlockDeclaration */ || kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 181 /* FunctionType */ || kind === 279 /* MissingDeclaration */ || kind === 267 /* NamespaceExportDeclaration */;
+  return kind === 172 /* ClassStaticBlockDeclaration */ || kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 279 /* MissingDeclaration */ || kind === 267 /* NamespaceExportDeclaration */;
 }
 function isQuestionOrExclamationToken(node) {
   return isQuestionToken(node) || isExclamationToken(node);
@@ -28280,6 +28293,7 @@ var Parser;
     const hasJSDoc = hasPrecedingJSDocComment();
     const modifiers = parseModifiersForConstructorType();
     const isConstructorType = parseOptional(103 /* NewKeyword */);
+    Debug.assert(!modifiers || isConstructorType, "Per isStartOfFunctionOrConstructorType, a function type cannot have modifiers.");
     const typeParameters = parseTypeParameters();
     const parameters = parseParameters(4 /* Type */);
     const type = parseReturnType(
@@ -28288,8 +28302,6 @@ var Parser;
       false
     );
     const node = isConstructorType ? factory2.createConstructorTypeNode(modifiers, typeParameters, parameters, type) : factory2.createFunctionTypeNode(typeParameters, parameters, type);
-    if (!isConstructorType)
-      node.modifiers = modifiers;
     return withJSDoc(finishNode(node, pos), hasJSDoc);
   }
   function parseKeywordAndNoDot() {
@@ -42585,6 +42597,7 @@ function createTypeChecker(host) {
   let inlineLevel = 0;
   let currentNode;
   let varianceTypeParameter;
+  let isInferencePartiallyBlocked = false;
   const emptySymbols = createSymbolTable();
   const arrayVariances = [1 /* Covariant */];
   const compilerOptions = host.getCompilerOptions();
@@ -43016,7 +43029,9 @@ function createTypeChecker(host) {
         toMarkSkip = toMarkSkip.parent;
       } while (toMarkSkip && toMarkSkip !== containingCall);
     }
+    isInferencePartiallyBlocked = true;
     const result = runWithoutResolvedSignatureCaching(node, fn);
+    isInferencePartiallyBlocked = false;
     if (containingCall) {
       let toMarkSkip = node;
       do {
@@ -53062,6 +53077,7 @@ function createTypeChecker(host) {
     const typeParameter = getTypeParameterFromMappedType(type);
     const constraintType = getConstraintTypeFromMappedType(type);
     const nameType = getNameTypeFromMappedType(type.target || type);
+    const isFilteringMappedType = nameType && isTypeAssignableTo(nameType, typeParameter);
     const templateType = getTemplateTypeFromMappedType(type.target || type);
     const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
     const templateModifiers = getMappedTypeModifiers(type);
@@ -53099,7 +53115,7 @@ function createTypeChecker(host) {
           prop.links.keyType = keyType;
           if (modifiersProp) {
             prop.links.syntheticOrigin = modifiersProp;
-            prop.declarations = nameType ? void 0 : modifiersProp.declarations;
+            prop.declarations = !nameType || isFilteringMappedType ? modifiersProp.declarations : void 0;
           }
           members.set(propName, prop);
         }
@@ -61834,17 +61850,6 @@ function createTypeChecker(host) {
   function getBaseTypeOfLiteralTypeForComparison(type) {
     return type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & (256 /* NumberLiteral */ | 32 /* Enum */) ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralTypeForComparison) : type;
   }
-  function getValueOfResult(type) {
-    const valueOf = getPropertyOfType(type, "valueOf");
-    if (valueOf) {
-      const signatures = getSignaturesOfType(getTypeOfSymbol(valueOf), 0 /* Call */);
-      if (signatures && signatures.length > 0) {
-        const returnType = getReturnTypeOfSignature(signatures[0]);
-        return returnType;
-      }
-    }
-    return type;
-  }
   function getWidenedLiteralType(type) {
     return type.flags & 1056 /* EnumLike */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLikeType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
   }
@@ -63363,7 +63368,7 @@ function createTypeChecker(host) {
         111551 /* Value */ | 1048576 /* ExportValue */,
         getCannotFindNameDiagnosticForName(node),
         node,
-        !isWriteOnlyAccess(node),
+        !isWriteOnlyUsage(node),
         /*excludeGlobals*/
         false
       ) || unknownSymbol;
@@ -68181,8 +68186,8 @@ function createTypeChecker(host) {
     }
     return nonNullType;
   }
-  function checkPropertyAccessExpression(node, checkMode) {
-    return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode);
+  function checkPropertyAccessExpression(node, checkMode, writeOnly) {
+    return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode, writeOnly);
   }
   function checkPropertyAccessChain(node, checkMode) {
     const leftType = checkExpression(node.expression);
@@ -68313,7 +68318,7 @@ function createTypeChecker(host) {
       false
     ) === getDeclaringConstructor(prop);
   }
-  function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode) {
+  function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode, writeOnly) {
     const parentSymbol = getNodeLinks(left).resolvedSymbol;
     const assignmentKind = getAssignmentTargetKind(node);
     const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
@@ -68412,13 +68417,12 @@ function createTypeChecker(host) {
       checkPropertyNotUsedBeforeDeclaration(prop, node, right);
       markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol));
       getNodeLinks(node).resolvedSymbol = prop;
-      const writing = isWriteAccess(node);
-      checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, writing, apparentType, prop);
+      checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, isWriteAccess(node), apparentType, prop);
       if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
         error(right, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, idText(right));
         return errorType;
       }
-      propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
+      propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writeOnly || isWriteOnlyAccess(node) ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
     }
     return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
   }
@@ -68734,7 +68738,7 @@ function createTypeChecker(host) {
     if (!hasPrivateModifier && !hasPrivateIdentifier) {
       return;
     }
-    if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
+    if (nodeForCheckWriteOnly && isWriteOnlyUsage(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
       return;
     }
     if (isSelfTypeAccess2) {
@@ -69669,7 +69673,7 @@ function createTypeChecker(host) {
     const isTaggedTemplate = node.kind === 212 /* TaggedTemplateExpression */;
     const isDecorator2 = node.kind === 167 /* Decorator */;
     const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
-    const reportErrors2 = !candidatesOutArray;
+    const reportErrors2 = !isInferencePartiallyBlocked && !candidatesOutArray;
     let typeArguments;
     if (!isDecorator2 && !isSuperCall(node)) {
       typeArguments = node.typeArguments;
@@ -72916,17 +72920,9 @@ function createTypeChecker(host) {
             if (isTypeAny(left2) || isTypeAny(right2)) {
               return true;
             }
-            if (!(left2.flags & 134348796 /* Primitive */))
-              left2 = getValueOfResult(left2);
-            if (!(right2.flags & 134348796 /* Primitive */))
-              right2 = getValueOfResult(right2);
             const leftAssignableToNumber = isTypeAssignableTo(left2, numberOrBigIntType);
-            if (leftAssignableToNumber) {
-              const rightAssignableToNumber = isTypeAssignableTo(right2, numberOrBigIntType);
-              if (rightAssignableToNumber)
-                return true;
-            }
-            return isTypeAssignableTo(left2, stringType) && isTypeAssignableTo(right2, stringType);
+            const rightAssignableToNumber = isTypeAssignableTo(right2, numberOrBigIntType);
+            return leftAssignableToNumber && rightAssignableToNumber || !leftAssignableToNumber && !rightAssignableToNumber && areTypesComparable(left2, right2);
           });
         }
         return booleanType;
@@ -73056,6 +73052,16 @@ function createTypeChecker(host) {
         addLazyDiagnostic(checkAssignmentOperatorWorker);
       }
       function checkAssignmentOperatorWorker() {
+        let assigneeType = leftType;
+        if (isCompoundAssignment(operatorToken.kind) && left.kind === 208 /* PropertyAccessExpression */) {
+          assigneeType = checkPropertyAccessExpression(
+            left,
+            /*checkMode*/
+            void 0,
+            /*writeOnly*/
+            true
+          );
+        }
         if (checkReferenceExpression(
           left,
           Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access,
@@ -73068,7 +73074,7 @@ function createTypeChecker(host) {
               headMessage = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target;
             }
           }
-          checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right, headMessage);
+          checkTypeAssignableToAndOptionallyElaborate(valueType, assigneeType, left, right, headMessage);
         }
       }
     }
@@ -74755,6 +74761,17 @@ function createTypeChecker(host) {
             lastSeenNonAmbientDeclaration = node;
           }
         }
+        if (isInJSFile(current) && isFunctionLike(current) && current.jsDoc) {
+          for (const node2 of current.jsDoc) {
+            if (node2.tags) {
+              for (const tag of node2.tags) {
+                if (isJSDocOverloadTag(tag)) {
+                  hasOverloads = true;
+                }
+              }
+            }
+          }
+        }
       }
     }
     if (multipleConstructorImplementation) {
@@ -74792,8 +74809,9 @@ function createTypeChecker(host) {
         const bodySignature = getSignatureFromDeclaration(bodyDeclaration);
         for (const signature of signatures) {
           if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
+            const errorNode = signature.declaration && isJSDocSignature(signature.declaration) ? signature.declaration.parent.tagName : signature.declaration;
             addRelatedInfo(
-              error(signature.declaration, Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature),
+              error(errorNode, Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature),
               createDiagnosticForNode(bodyDeclaration, Diagnostics.The_implementation_signature_is_declared_here)
             );
             break;
@@ -81409,7 +81427,6 @@ function createTypeChecker(host) {
       case 299 /* PropertyAssignment */:
       case 300 /* ShorthandPropertyAssignment */:
       case 267 /* NamespaceExportDeclaration */:
-      case 181 /* FunctionType */:
       case 279 /* MissingDeclaration */:
         return find(node.modifiers, isModifier);
       default: