@typescript-deploys/pr-build 5.1.0-pr-50951-7 → 5.1.0-pr-53413-14

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230320`;
+var version = `${versionMajorMinor}.0-insiders.20230321`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6634,6 +6634,7 @@ var Diagnostics = {
   A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_file_0_instead: diag(2846, 1 /* Error */, "A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_f_2846", "A declaration file cannot be imported without 'import type'. Did you mean to import an implementation file '{0}' instead?"),
   A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value: diag(2847, 1 /* Error */, "A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value_2847", "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value."),
   The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression: diag(2848, 1 /* Error */, "The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression_2848", "The right-hand side of an 'instanceof' expression must not be an instantiation expression."),
+  Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1: diag(2849, 1 /* Error */, "Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1_2849", "Target signature provides too few arguments. Expected {0} or more, but got {1}."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -10242,36 +10243,32 @@ function getModifiers(node) {
     return filter(node.modifiers, isModifier);
   }
 }
-function getJSDocParameterTagsWorker(node, noCache) {
-  const declaration = getRootDeclaration(node);
-  if (isParameter(declaration)) {
-    const name = isBindingElement(node) ? node.propertyName || node.name : node.name;
-    const signatureDeclaration = declaration.parent;
-    const jsDocParameterTags = filter(getJSDocTagsWorker(signatureDeclaration, noCache), isJSDocParameterTag);
-    if (length(jsDocParameterTags) === 0) {
-      return emptyArray;
-    }
-    if (isIdentifier(name)) {
-      return filter(jsDocParameterTags, (tag) => isIdentifier(tag.name) && tag.name.escapedText === name.escapedText);
-    }
-    const i = signatureDeclaration.parameters.indexOf(declaration);
-    Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
-    if (i < length(jsDocParameterTags)) {
-      return [jsDocParameterTags[i]];
+function getJSDocParameterTagsWorker(param, noCache) {
+  if (param.name) {
+    if (isIdentifier(param.name)) {
+      const name = param.name.escapedText;
+      return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
+    } else {
+      const i = param.parent.parameters.indexOf(param);
+      Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
+      const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
+      if (i < paramTags.length) {
+        return [paramTags[i]];
+      }
     }
   }
   return emptyArray;
 }
-function getJSDocParameterTags(node) {
+function getJSDocParameterTags(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     false
   );
 }
-function getJSDocParameterTagsNoCache(node) {
+function getJSDocParameterTagsNoCache(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     true
   );
@@ -10378,7 +10375,7 @@ function getJSDocTypeTag(node) {
 }
 function getJSDocType(node) {
   let tag = getFirstJSDocTag(node, isJSDocTypeTag);
-  if (!tag && (isParameter(node) || isBindingElement(node))) {
+  if (!tag && isParameter(node)) {
     tag = find(getJSDocParameterTags(node), (tag2) => !!tag2.typeExpression);
   }
   return tag && tag.typeExpression && tag.typeExpression.type;
@@ -12715,17 +12712,20 @@ function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
 function isIdentifierTypePredicate(predicate) {
   return predicate && predicate.kind === 1 /* Identifier */;
 }
-function getPropertyAssignment(objectLiteral, key, key2) {
-  return objectLiteral.properties.filter((property) => {
-    if (property.kind === 300 /* PropertyAssignment */) {
-      const propName = tryGetTextOfPropertyName(property.name);
-      return key === propName || !!key2 && key2 === propName;
-    }
-    return false;
+function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
+  return forEach(objectLiteral == null ? void 0 : objectLiteral.properties, (property) => {
+    if (!isPropertyAssignment(property))
+      return void 0;
+    const propName = tryGetTextOfPropertyName(property.name);
+    return key === propName || key2 && key2 === propName ? callback(property) : void 0;
   });
 }
 function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
-  return firstDefined(getPropertyAssignment(objectLiteral, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
+  return forEachPropertyAssignment(
+    objectLiteral,
+    propKey,
+    (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0
+  );
 }
 function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
   if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
@@ -12734,11 +12734,10 @@ function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
   }
 }
 function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
-  return firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
+  return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
 }
-function getTsConfigPropArray(tsConfigSourceFile, propKey) {
-  const jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile);
-  return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : emptyArray;
+function forEachTsConfigPropArray(tsConfigSourceFile, propKey, callback) {
+  return forEachPropertyAssignment(getTsConfigObjectLiteralExpression(tsConfigSourceFile), propKey, callback);
 }
 function getContainingFunction(node) {
   return findAncestor(node.parent, isFunctionLike);
@@ -13699,7 +13698,7 @@ function getJSDocCommentsAndTags(hostNode, noCache) {
     if (hasJSDocNodes(node)) {
       result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
     }
-    if (node.kind === 167 /* Parameter */ || node.kind === 206 /* BindingElement */) {
+    if (node.kind === 167 /* Parameter */) {
       result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
       break;
     }
@@ -35500,7 +35499,7 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
         if (sourceFile) {
           const fileName = configFileName || "tsconfig.json";
           const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
-          const nodeValue = firstDefined(getTsConfigPropArray(sourceFile, "files"), (property) => property.initializer);
+          const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property) => property.initializer);
           const error = createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, nodeValue, diagnosticMessage, fileName);
           errors.push(error);
         } else {
@@ -47196,8 +47195,11 @@ function createTypeChecker(host) {
         }
         return typeToTypeNodeHelper(type2, context);
       }
+      function isMappedTypeHomomorphic(type2) {
+        return !!getHomomorphicTypeVariable(type2);
+      }
       function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) {
-        return isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 262144 /* TypeParameter */);
+        return !!type2.target && isMappedTypeHomomorphic(type2.target) && !isMappedTypeHomomorphic(type2);
       }
       function createMappedTypeNodeFromType(type2) {
         Debug.assert(!!(type2.flags & 524288 /* Object */));
@@ -50647,12 +50649,6 @@ function createTypeChecker(host) {
   }
   function getTypeForBindingElement(declaration) {
     const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
-    if (isInJSFile(declaration) && isParameterDeclaration(declaration)) {
-      const type = tryGetTypeFromEffectiveTypeNode(declaration);
-      if (type) {
-        return type;
-      }
-    }
     const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
     return parentType && getBindingElementTypeFromParentType(declaration, parentType);
   }
@@ -53371,7 +53367,7 @@ function createTypeChecker(host) {
     return simplified !== type ? simplified : getConstraintOfType(type);
   }
   function getConstraintFromIndexedAccess(type) {
-    if (isMappedTypeGenericIndexedAccess(type)) {
+    if (isMappedTypeGenericIndexedAccess(type) || isGenericMappedType(type.objectType)) {
       return substituteIndexedMappedType(type.objectType, type.indexType);
     }
     const indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
@@ -55759,6 +55755,12 @@ function createTypeChecker(host) {
       i--;
       const source = types[i];
       if (hasEmptyObject || source.flags & 469499904 /* StructuredOrInstantiable */) {
+        if (source.flags & 262144 /* TypeParameter */ && getBaseConstraintOrType(source).flags & 1048576 /* Union */) {
+          if (isTypeRelatedTo(source, getUnionType(map(types, (t) => t === source ? neverType : t)), strictSubtypeRelation)) {
+            orderedRemoveItemAt(types, i);
+          }
+          continue;
+        }
         const keyProperty = source.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */) ? find(getPropertiesOfType(source), (p) => isUnitType(getTypeOfSymbol(p))) : void 0;
         const keyPropertyType = keyProperty && getRegularTypeOfLiteralType(getTypeOfSymbol(keyProperty));
         for (const target of types) {
@@ -57293,7 +57295,10 @@ function createTypeChecker(host) {
           const declarations = concatenate(leftProp.declarations, rightProp.declarations);
           const flags = 4 /* Property */ | leftProp.flags & 16777216 /* Optional */;
           const result = createSymbol(flags, leftProp.escapedName);
-          result.links.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* Subtype */);
+          const leftType = getTypeOfSymbol(leftProp);
+          const leftTypeWithoutUndefined = removeMissingOrUndefinedType(leftType);
+          const rightTypeWithoutUndefined = removeMissingOrUndefinedType(rightType);
+          result.links.type = leftTypeWithoutUndefined === rightTypeWithoutUndefined ? leftType : getUnionType([leftType, rightTypeWithoutUndefined], 2 /* Subtype */);
           result.links.leftSpread = leftProp;
           result.links.rightSpread = rightProp;
           result.declarations = declarations;
@@ -58716,6 +58721,9 @@ function createTypeChecker(host) {
     const targetCount = getParameterCount(target);
     const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
     if (sourceHasMoreParameters) {
+      if (reportErrors2 && !(checkMode & 8 /* StrictArity */)) {
+        errorReporter(Diagnostics.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1, getMinArgumentCount(source), targetCount);
+      }
       return 0 /* False */;
     }
     if (source.typeParameters && source.typeParameters !== target.typeParameters) {
@@ -60424,6 +60432,26 @@ function createTypeChecker(host) {
           )) {
             return result2;
           }
+          if (sourceFlags & 8388608 /* IndexedAccess */) {
+            const indexType = source2.indexType;
+            if (indexType.flags & 4194304 /* Index */) {
+              const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
+              const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
+              const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
+              if (result2 = isRelatedTo(
+                constraint2,
+                target2,
+                1 /* Source */,
+                /*reportErrors*/
+                false,
+                /*headMessage*/
+                void 0,
+                intersectionState
+              )) {
+                return result2;
+              }
+            }
+          }
           if (isMappedTypeGenericIndexedAccess(source2)) {
             const indexConstraint = getConstraintOfType(source2.indexType);
             if (indexConstraint) {
@@ -61615,7 +61643,7 @@ function createTypeChecker(host) {
         return type.symbol;
       }
       if (isTupleType(type)) {
-        return type;
+        return type.target;
       }
     }
     if (type.flags & 262144 /* TypeParameter */) {
@@ -62858,21 +62886,19 @@ function createTypeChecker(host) {
       const saveInferencePriority = inferencePriority;
       inferencePriority = 2048 /* MaxValue */;
       const saveExpandingFlags = expandingFlags;
-      const sourceIdentity = getRecursionIdentity(source);
-      const targetIdentity = getRecursionIdentity(target);
-      if (contains(sourceStack, sourceIdentity))
+      (sourceStack != null ? sourceStack : sourceStack = []).push(source);
+      (targetStack != null ? targetStack : targetStack = []).push(target);
+      if (isDeeplyNestedType(source, sourceStack, sourceStack.length, 2))
         expandingFlags |= 1 /* Source */;
-      if (contains(targetStack, targetIdentity))
+      if (isDeeplyNestedType(target, targetStack, targetStack.length, 2))
         expandingFlags |= 2 /* Target */;
       if (expandingFlags !== 3 /* Both */) {
-        (sourceStack || (sourceStack = [])).push(sourceIdentity);
-        (targetStack || (targetStack = [])).push(targetIdentity);
         action(source, target);
-        targetStack.pop();
-        sourceStack.pop();
       } else {
         inferencePriority = -1 /* Circularity */;
       }
+      targetStack.pop();
+      sourceStack.pop();
       expandingFlags = saveExpandingFlags;
       visited.set(key, inferencePriority);
       inferencePriority = Math.min(inferencePriority, saveInferencePriority);
@@ -115624,8 +115650,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         if (!referenceInfo)
           return void 0;
         const { sourceFile, index } = referenceInfo;
-        const referencesSyntax = firstDefined(
-          getTsConfigPropArray(sourceFile, "references"),
+        const referencesSyntax = forEachTsConfigPropArray(
+          sourceFile,
+          "references",
           (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
         );
         return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
@@ -115696,26 +115723,24 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, ...args) {
     let needCompilerDiagnostic = true;
-    const pathsSyntax = getOptionPathsSyntax();
-    for (const pathProp of pathsSyntax) {
+    forEachOptionPathsSyntax((pathProp) => {
       if (isObjectLiteralExpression(pathProp.initializer)) {
-        for (const keyProps of getPropertyAssignment(pathProp.initializer, key)) {
+        forEachPropertyAssignment(pathProp.initializer, key, (keyProps) => {
           const initializer = keyProps.initializer;
           if (isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) {
             programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, ...args));
             needCompilerDiagnostic = false;
           }
-        }
+        });
       }
-    }
+    });
     if (needCompilerDiagnostic) {
       programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
   function createDiagnosticForOptionPaths(onKey, key, message, ...args) {
     let needCompilerDiagnostic = true;
-    const pathsSyntax = getOptionPathsSyntax();
-    for (const pathProp of pathsSyntax) {
+    forEachOptionPathsSyntax((pathProp) => {
       if (isObjectLiteralExpression(pathProp.initializer) && createOptionDiagnosticInObjectLiteralSyntax(
         pathProp.initializer,
         onKey,
@@ -115727,21 +115752,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       )) {
         needCompilerDiagnostic = false;
       }
-    }
+    });
     if (needCompilerDiagnostic) {
       programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
-  function getOptionsSyntaxByName(name) {
-    const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
-    return compilerOptionsObjectLiteralSyntax && getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name);
+  function forEachOptionsSyntaxByName(name, callback) {
+    return forEachPropertyAssignment(getCompilerOptionsObjectLiteralSyntax(), name, callback);
   }
-  function getOptionPathsSyntax() {
-    return getOptionsSyntaxByName("paths") || emptyArray;
+  function forEachOptionPathsSyntax(callback) {
+    return forEachOptionsSyntaxByName("paths", callback);
   }
   function getOptionsSyntaxByValue(name, value) {
-    const syntaxByName = getOptionsSyntaxByName(name);
-    return syntaxByName && firstDefined(syntaxByName, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
+    return forEachOptionsSyntaxByName(name, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
   }
   function getOptionsSyntaxByArrayElementValue(name, value) {
     const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
@@ -115771,8 +115794,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     );
   }
   function createDiagnosticForReference(sourceFile, index, message, ...args) {
-    const referencesSyntax = firstDefined(
-      getTsConfigPropArray(sourceFile || options.configFile, "references"),
+    const referencesSyntax = forEachTsConfigPropArray(
+      sourceFile || options.configFile,
+      "references",
       (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
     );
     if (referencesSyntax && referencesSyntax.elements.length > index) {
@@ -115794,29 +115818,25 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function getCompilerOptionsObjectLiteralSyntax() {
     if (_compilerOptionsObjectLiteralSyntax === void 0) {
-      _compilerOptionsObjectLiteralSyntax = false;
-      const jsonObjectLiteral = getTsConfigObjectLiteralExpression(options.configFile);
-      if (jsonObjectLiteral) {
-        for (const prop of getPropertyAssignment(jsonObjectLiteral, "compilerOptions")) {
-          if (isObjectLiteralExpression(prop.initializer)) {
-            _compilerOptionsObjectLiteralSyntax = prop.initializer;
-            break;
-          }
-        }
-      }
+      _compilerOptionsObjectLiteralSyntax = forEachPropertyAssignment(
+        getTsConfigObjectLiteralExpression(options.configFile),
+        "compilerOptions",
+        (prop) => isObjectLiteralExpression(prop.initializer) ? prop.initializer : void 0
+      ) || false;
     }
     return _compilerOptionsObjectLiteralSyntax || void 0;
   }
   function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, ...args) {
-    const props = getPropertyAssignment(objectLiteral, key1, key2);
-    for (const prop of props) {
+    let needsCompilerDiagnostic = false;
+    forEachPropertyAssignment(objectLiteral, key1, (prop) => {
       if ("messageText" in message) {
         programDiagnostics.add(createDiagnosticForNodeFromMessageChain(options.configFile, onKey ? prop.name : prop.initializer, message));
       } else {
         programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, ...args));
       }
-    }
-    return !!props.length;
+      needsCompilerDiagnostic = true;
+    }, key2);
+    return needsCompilerDiagnostic;
   }
   function createRedundantOptionDiagnostic(errorOnOption, redundantWithOption) {
     const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();