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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-insiders.20230216`;
+      version = `${versionMajorMinor}.0-insiders.20230217`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13027,6 +13027,36 @@ ${lanes.join("\n")}
   function nodeIsPresent(node) {
     return !nodeIsMissing(node);
   }
+  function isGrammarError(parent2, child) {
+    if (isTypeParameterDeclaration(parent2))
+      return child === parent2.expression;
+    if (isClassStaticBlockDeclaration(parent2))
+      return child === parent2.modifiers;
+    if (isPropertySignature(parent2))
+      return child === parent2.initializer;
+    if (isPropertyDeclaration(parent2))
+      return child === parent2.questionToken && isAutoAccessorPropertyDeclaration(parent2);
+    if (isPropertyAssignment(parent2))
+      return child === parent2.modifiers || child === parent2.questionToken || child === parent2.exclamationToken || isGrammarErrorElement(parent2.modifiers, child, isModifierLike);
+    if (isShorthandPropertyAssignment(parent2))
+      return child === parent2.equalsToken || child === parent2.modifiers || child === parent2.questionToken || child === parent2.exclamationToken || isGrammarErrorElement(parent2.modifiers, child, isModifierLike);
+    if (isMethodDeclaration(parent2))
+      return child === parent2.exclamationToken;
+    if (isConstructorDeclaration(parent2))
+      return child === parent2.typeParameters || child === parent2.type || isGrammarErrorElement(parent2.typeParameters, child, isTypeParameterDeclaration);
+    if (isGetAccessorDeclaration(parent2))
+      return child === parent2.typeParameters || isGrammarErrorElement(parent2.typeParameters, child, isTypeParameterDeclaration);
+    if (isSetAccessorDeclaration(parent2))
+      return child === parent2.typeParameters || child === parent2.type || isGrammarErrorElement(parent2.typeParameters, child, isTypeParameterDeclaration);
+    if (isNamespaceExportDeclaration(parent2))
+      return child === parent2.modifiers || isGrammarErrorElement(parent2.modifiers, child, isModifierLike);
+    return false;
+  }
+  function isGrammarErrorElement(nodeArray, child, isElement) {
+    if (!nodeArray || isArray(child) || !isElement(child))
+      return false;
+    return contains(nodeArray, child);
+  }
   function insertStatementsAfterPrologue(to, from, isPrologueDirective2) {
     if (from === void 0 || from.length === 0)
       return to;
@@ -17361,20 +17391,39 @@ ${lanes.join("\n")}
   function isWriteAccess(node) {
     return accessKind(node) !== 0 /* Read */;
   }
+  function isWriteOnlyUsage(node) {
+    return accessKindForUsageChecks(node) === 1 /* Write */;
+  }
+  function isWriteUsage(node) {
+    return accessKindForUsageChecks(node) !== 0 /* Read */;
+  }
+  function accessKindForUsageChecks(node) {
+    const kind = accessKind(node);
+    const { parent: parent2 } = node;
+    switch (parent2 == null ? void 0 : parent2.kind) {
+      case 222 /* PostfixUnaryExpression */:
+      case 221 /* PrefixUnaryExpression */:
+      case 223 /* BinaryExpression */:
+        return kind === 2 /* ReadWrite */ ? writeOrReadWrite() : kind;
+      default:
+        return kind;
+    }
+    function writeOrReadWrite() {
+      return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
+    }
+  }
   function accessKind(node) {
     const { parent: parent2 } = node;
-    if (!parent2)
-      return 0 /* Read */;
-    switch (parent2.kind) {
+    switch (parent2 == null ? void 0 : parent2.kind) {
       case 214 /* ParenthesizedExpression */:
         return accessKind(parent2);
       case 222 /* PostfixUnaryExpression */:
       case 221 /* PrefixUnaryExpression */:
         const { operator } = parent2;
-        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 } = parent2;
-        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 parent2.name !== node ? 0 /* Read */ : accessKind(parent2);
       case 299 /* PropertyAssignment */: {
@@ -17388,9 +17437,6 @@ ${lanes.join("\n")}
       default:
         return 0 /* Read */;
     }
-    function writeOrReadWrite() {
-      return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
-    }
   }
   function reverseAccessKind(a) {
     switch (a) {
@@ -27168,7 +27214,7 @@ ${lanes.join("\n")}
   }
   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);
@@ -30706,6 +30752,7 @@ ${lanes.join("\n")}
           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(
@@ -30714,8 +30761,6 @@ ${lanes.join("\n")}
             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() {
@@ -44970,6 +45015,7 @@ ${lanes.join("\n")}
     let inlineLevel = 0;
     let currentNode;
     let varianceTypeParameter;
+    let isInferencePartiallyBlocked = false;
     const emptySymbols = createSymbolTable();
     const arrayVariances = [1 /* Covariant */];
     const compilerOptions = host.getCompilerOptions();
@@ -45401,7 +45447,9 @@ ${lanes.join("\n")}
           toMarkSkip = toMarkSkip.parent;
         } while (toMarkSkip && toMarkSkip !== containingCall);
       }
+      isInferencePartiallyBlocked = true;
       const result = runWithoutResolvedSignatureCaching(node, fn);
+      isInferencePartiallyBlocked = false;
       if (containingCall) {
         let toMarkSkip = node;
         do {
@@ -55447,6 +55495,7 @@ ${lanes.join("\n")}
       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);
@@ -55484,7 +55533,7 @@ ${lanes.join("\n")}
             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);
           }
@@ -64219,17 +64268,6 @@ ${lanes.join("\n")}
     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;
     }
@@ -65748,7 +65786,7 @@ ${lanes.join("\n")}
           111551 /* Value */ | 1048576 /* ExportValue */,
           getCannotFindNameDiagnosticForName(node),
           node,
-          !isWriteOnlyAccess(node),
+          !isWriteOnlyUsage(node),
           /*excludeGlobals*/
           false
         ) || unknownSymbol;
@@ -70566,8 +70604,8 @@ ${lanes.join("\n")}
       }
       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);
@@ -70698,7 +70736,7 @@ ${lanes.join("\n")}
         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);
@@ -70797,13 +70835,12 @@ ${lanes.join("\n")}
         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);
     }
@@ -71119,7 +71156,7 @@ ${lanes.join("\n")}
       if (!hasPrivateModifier && !hasPrivateIdentifier) {
         return;
       }
-      if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
+      if (nodeForCheckWriteOnly && isWriteOnlyUsage(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
         return;
       }
       if (isSelfTypeAccess2) {
@@ -72054,7 +72091,7 @@ ${lanes.join("\n")}
       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;
@@ -75301,17 +75338,9 @@ ${lanes.join("\n")}
               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;
@@ -75441,6 +75470,16 @@ ${lanes.join("\n")}
           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,
@@ -75453,7 +75492,7 @@ ${lanes.join("\n")}
                 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);
           }
         }
       }
@@ -77140,6 +77179,17 @@ ${lanes.join("\n")}
               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) {
@@ -77177,8 +77227,9 @@ ${lanes.join("\n")}
           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;
@@ -83794,7 +83845,6 @@ ${lanes.join("\n")}
         case 299 /* PropertyAssignment */:
         case 300 /* ShorthandPropertyAssignment */:
         case 267 /* NamespaceExportDeclaration */:
-        case 181 /* FunctionType */:
         case 279 /* MissingDeclaration */:
           return find(node.modifiers, isModifier);
         default:
@@ -146166,7 +146216,14 @@ ${lanes.join("\n")}
     changeTracker.replaceNode(file, declaration, property);
   }
   function updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName) {
-    const assignment = factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer);
+    let assignment = factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer);
+    if (assignment.modifiers || assignment.questionToken || assignment.exclamationToken) {
+      if (assignment === declaration)
+        assignment = factory.cloneNode(assignment);
+      assignment.modifiers = void 0;
+      assignment.questionToken = void 0;
+      assignment.exclamationToken = void 0;
+    }
     changeTracker.replacePropertyAssignment(file, declaration, assignment);
   }
   function updateFieldDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) {
@@ -165929,7 +165986,7 @@ ${options.prefix}` : "\n" : options.prefix
       }
       function processChildNode(child, inheritedIndentation, parent2, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
         Debug.assert(!nodeIsSynthesized(child));
-        if (nodeIsMissing(child)) {
+        if (nodeIsMissing(child) || isGrammarError(parent2, child)) {
           return inheritedIndentation;
         }
         const childStartPos = child.getStart(sourceFile);
@@ -168605,6 +168662,7 @@ ${options.prefix}` : "\n" : options.prefix
     isGetOrSetAccessorDeclaration: () => isGetOrSetAccessorDeclaration,
     isGlobalDeclaration: () => isGlobalDeclaration,
     isGlobalScopeAugmentation: () => isGlobalScopeAugmentation,
+    isGrammarError: () => isGrammarError,
     isHeritageClause: () => isHeritageClause,
     isHoistedFunction: () => isHoistedFunction,
     isHoistedVariableStatement: () => isHoistedVariableStatement,
@@ -169050,6 +169108,8 @@ ${options.prefix}` : "\n" : options.prefix
     isWithStatement: () => isWithStatement,
     isWriteAccess: () => isWriteAccess,
     isWriteOnlyAccess: () => isWriteOnlyAccess,
+    isWriteOnlyUsage: () => isWriteOnlyUsage,
+    isWriteUsage: () => isWriteUsage,
     isYieldExpression: () => isYieldExpression,
     jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
     keywordPart: () => keywordPart,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // 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 = [];
@@ -21124,6 +21124,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(
@@ -21132,8 +21133,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() {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.0.0-pr-52807-23",
+  "version": "5.0.0-pr-50431-13",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [