@typescript-deploys/pr-build 5.2.0-pr-54282-26 → 5.2.0-pr-54281-25

package/lib/tsc.js

@@ -7729,6 +7729,9 @@ var Diagnostics = {
   Use_type_0: diag(95181, 3 /* Message */, "Use_type_0_95181", "Use 'type {0}'"),
   Fix_all_with_type_only_imports: diag(95182, 3 /* Message */, "Fix_all_with_type_only_imports_95182", "Fix all with type-only imports"),
   Cannot_move_statements_to_the_selected_file: diag(95183, 3 /* Message */, "Cannot_move_statements_to_the_selected_file_95183", "Cannot move statements to the selected file"),
+  Inline_variable: diag(95184, 3 /* Message */, "Inline_variable_95184", "Inline variable"),
+  Could_not_find_variable_to_inline: diag(95185, 3 /* Message */, "Could_not_find_variable_to_inline_95185", "Could not find variable to inline."),
+  Variables_with_multiple_declarations_cannot_be_inlined: diag(95186, 3 /* Message */, "Variables_with_multiple_declarations_cannot_be_inlined_95186", "Variables with multiple declarations cannot be inlined."),
   No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
   Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
   JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -10049,15 +10052,6 @@ function createTextChangeRange(span, newLength) {
   return { span, newLength };
 }
 var unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
-function getTypeParameterOwner(d) {
-  if (d && d.kind === 167 /* TypeParameter */) {
-    for (let current = d; current; current = current.parent) {
-      if (isFunctionLike(current) || isClassLike(current) || current.kind === 263 /* InterfaceDeclaration */) {
-        return current;
-      }
-    }
-  }
-}
 function isParameterPropertyDeclaration(node, parent) {
   return isParameter(node) && hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) && parent.kind === 175 /* Constructor */;
 }
@@ -57454,114 +57448,6 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
-  function getNarrowConditionalType(root, narrowMapper, mapper, aliasSymbol, aliasTypeArguments) {
-    let result;
-    let extraTypes;
-    let tailCount = 0;
-    while (true) {
-      if (tailCount === 1e3) {
-        error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
-        return errorType;
-      }
-      const checkType = instantiateNarrowType(getActualTypeVariable(root.checkType), narrowMapper, mapper);
-      const extendsType = instantiateType(root.extendsType, mapper);
-      if (checkType === errorType || extendsType === errorType) {
-        return errorType;
-      }
-      if (checkType === wildcardType || extendsType === wildcardType) {
-        return wildcardType;
-      }
-      const checkTypeDeferred = false;
-      let combinedMapper;
-      if (root.inferTypeParameters) {
-        const freshParams = sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
-        const freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : void 0;
-        const context = createInferenceContext(
-          freshParams,
-          /*signature*/
-          void 0,
-          0 /* None */
-        );
-        if (freshMapper) {
-          const freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
-          for (const p of freshParams) {
-            if (root.inferTypeParameters.indexOf(p) === -1) {
-              p.mapper = freshCombinedMapper;
-            }
-          }
-        }
-        if (!checkTypeDeferred) {
-          inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
-        }
-        const innerMapper = combineTypeMappers(freshMapper, context.mapper);
-        combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
-      }
-      const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
-      if (true) {
-        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */) {
-            (extraTypes || (extraTypes = [])).push(
-              instantiateNarrowType(getTypeFromTypeNode(root.node.trueType), narrowMapper, combinedMapper || mapper)
-            );
-          }
-          const falseType2 = getTypeFromTypeNode(root.node.falseType);
-          if (falseType2.flags & 16777216 /* Conditional */) {
-            const newRoot = falseType2.root;
-            if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
-              root = newRoot;
-              continue;
-            }
-            if (canTailRecurse(falseType2, mapper)) {
-              continue;
-            }
-          }
-          result = instantiateNarrowType(falseType2, narrowMapper, mapper);
-          break;
-        }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
-          const trueType2 = getTypeFromTypeNode(root.node.trueType);
-          const trueMapper = combinedMapper || mapper;
-          if (canTailRecurse(trueType2, trueMapper)) {
-            continue;
-          }
-          result = instantiateNarrowType(trueType2, narrowMapper, trueMapper);
-          break;
-        }
-      }
-      result = createType(16777216 /* Conditional */);
-      result.root = root;
-      result.checkType = instantiateType(root.checkType, mapper);
-      result.extendsType = instantiateType(root.extendsType, mapper);
-      result.mapper = mapper;
-      result.combinedMapper = combinedMapper;
-      result.aliasSymbol = aliasSymbol || root.aliasSymbol;
-      result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper);
-      break;
-    }
-    return extraTypes ? getIntersectionType(append(extraTypes, result)) : result;
-    function canTailRecurse(newType, newMapper) {
-      if (newType.flags & 16777216 /* Conditional */ && newMapper) {
-        const newRoot = newType.root;
-        if (newRoot.outerTypeParameters) {
-          const typeParamMapper = combineTypeMappers(newType.mapper, newMapper);
-          const typeArguments = map(newRoot.outerTypeParameters, (t) => getMappedType(t, typeParamMapper));
-          const newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments);
-          const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : void 0;
-          if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 /* Union */ | 131072 /* Never */))) {
-            root = newRoot;
-            mapper = newRootMapper;
-            aliasSymbol = void 0;
-            aliasTypeArguments = void 0;
-            if (newRoot.aliasSymbol) {
-              tailCount++;
-            }
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-  }
   function getTypeFromInferTypeNode(node) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
@@ -58510,93 +58396,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function instantiateNarrowType(type, narrowMapper, mapper, noTopLevel = false) {
-    return type ? instantiateNarrowTypeWithAlias(
-      type,
-      narrowMapper,
-      mapper,
-      /*aliasSymbol*/
-      void 0,
-      /*aliasTypeArguments*/
-      void 0,
-      noTopLevel
-    ) : type;
-  }
-  function instantiateNarrowTypeWithAlias(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel) {
-    var _a;
-    if (!couldContainTypeVariables(type)) {
-      return type;
-    }
-    if (instantiationDepth === 100 || instantiationCount >= 5e6) {
-      (_a = tracing) == null ? void 0 : _a.instant(tracing.Phase.CheckTypes, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth, instantiationCount });
-      error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
-      return errorType;
-    }
-    totalInstantiationCount++;
-    instantiationCount++;
-    instantiationDepth++;
-    const result = instantiateNarrowTypeWorker(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel);
-    instantiationDepth--;
-    return result;
-  }
-  function instantiateNarrowTypeWorker(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel) {
-    const flags = type.flags;
-    if (flags & 262144 /* TypeParameter */) {
-      if (noTopLevel) {
-        return type;
-      }
-      return getMappedType(type, combineTypeMappers(mapper, narrowMapper));
-    }
-    if (flags & 8388608 /* IndexedAccess */) {
-      const newAliasSymbol = aliasSymbol || type.aliasSymbol;
-      const newAliasTypeArguments = aliasSymbol || !mapper ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
-      const objectType = instantiateType(type.objectType, mapper);
-      let indexType = instantiateType(type.indexType, mapper);
-      if (indexType.flags & 262144 /* TypeParameter */) {
-        indexType = getMappedType(indexType, narrowMapper);
-      }
-      return getIndexedAccessType(
-        objectType,
-        indexType,
-        type.accessFlags | 4 /* Writing */,
-        // Get the writing type
-        /*accessNode*/
-        void 0,
-        newAliasSymbol,
-        newAliasTypeArguments
-      );
-    }
-    if (flags & 16777216 /* Conditional */) {
-      return getNarrowConditionalTypeInstantiation(
-        type,
-        narrowMapper,
-        mapper ? combineTypeMappers(type.mapper, mapper) : type.mapper,
-        aliasSymbol,
-        aliasTypeArguments
-      );
-    }
-    return type;
-  }
-  function getNarrowConditionalTypeInstantiation(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments) {
-    const root = type.root;
-    if (root.outerTypeParameters) {
-      const typeArguments = mapper ? map(root.outerTypeParameters, (t) => getMappedType(t, mapper)) : root.outerTypeParameters;
-      let result;
-      const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
-      const checkType = root.checkType;
-      const distributionType = root.isDistributive ? getMappedType(checkType, combineTypeMappers(newMapper, narrowMapper)) : void 0;
-      if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
-        result = mapTypeWithAlias(getReducedType(distributionType), (t) => getNarrowConditionalType(root, narrowMapper, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments);
-        if (result.flags & 1048576 /* Union */) {
-          result = getIntersectionType(result.types, aliasSymbol, aliasTypeArguments);
-        }
-      } else {
-        result = getNarrowConditionalType(root, narrowMapper, newMapper, aliasSymbol, aliasTypeArguments);
-      }
-      return result;
-    }
-    return type;
-  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -66038,7 +65837,7 @@ function createTypeChecker(host) {
     return contextualType && !isGenericType(contextualType);
   }
   function getNarrowableTypeForReference(type, reference, checkMode) {
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (reference.flags & 8 /* Synthesized */ || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -66677,6 +66476,25 @@ function createTypeChecker(host) {
       return t.flags & 2097152 /* Intersection */ ? forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
     });
   }
+  function getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType) {
+    let literal = containingLiteral;
+    let type = contextualType;
+    while (type) {
+      const thisType = getThisTypeFromContextualType(type);
+      if (thisType) {
+        return thisType;
+      }
+      if (literal.parent.kind !== 302 /* PropertyAssignment */) {
+        break;
+      }
+      literal = literal.parent.parent;
+      type = getApparentTypeOfContextualType(
+        literal,
+        /*contextFlags*/
+        void 0
+      );
+    }
+  }
   function getContextualThisParameterType(func) {
     if (func.kind === 218 /* ArrowFunction */) {
       return void 0;
@@ -66699,22 +66517,9 @@ function createTypeChecker(host) {
           /*contextFlags*/
           void 0
         );
-        let literal = containingLiteral;
-        let type = contextualType;
-        while (type) {
-          const thisType = getThisTypeFromContextualType(type);
-          if (thisType) {
-            return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
-          }
-          if (literal.parent.kind !== 302 /* PropertyAssignment */) {
-            break;
-          }
-          literal = literal.parent.parent;
-          type = getApparentTypeOfContextualType(
-            literal,
-            /*contextFlags*/
-            void 0
-          );
+        const thisType = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
+        if (thisType) {
+          return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
         }
         return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
       }
@@ -66830,16 +66635,9 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
-      const functionFlags = getFunctionFlags(func);
-      const links = getNodeLinks(node);
-      if (links.contextualReturnType) {
-        if (functionFlags & 2 /* Async */) {
-          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
-        }
-        return links.contextualReturnType;
-      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
+        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -66852,7 +66650,7 @@ function createTypeChecker(host) {
           contextualReturnType = iterationReturnType;
         }
         if (functionFlags & 2 /* Async */) {
-          const contextualAwaitedType = getAwaitedTypeNoAlias(contextualReturnType);
+          const contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeNoAlias);
           return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
         }
         return contextualReturnType;
@@ -77946,55 +77744,17 @@ function createTypeChecker(host) {
     const returnType = getReturnTypeOfSignature(signature);
     const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
+      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 177 /* SetAccessor */) {
         if (node.expression) {
           error(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 175 /* Constructor */) {
-        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
           error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
         const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-        let actualReturnType = unwrappedReturnType;
-        const links = node.expression && getNodeLinks(node.expression);
-        if (links && !links.contextualReturnType) {
-          const outerTypeParameters = getOuterTypeParameters(
-            container,
-            /*includeThisTypes*/
-            false
-          );
-          const typeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(container));
-          const queryTypeParameters = typeParameters == null ? void 0 : typeParameters.filter(isQueryTypeParameter);
-          if (queryTypeParameters) {
-            const narrowMapper = createTypeMapper(queryTypeParameters, queryTypeParameters.map((tp) => {
-              const originalName = tp.exprName;
-              const fakeName = factory.cloneNode(originalName);
-              setParent(fakeName, node.parent);
-              setNodeFlags(fakeName, fakeName.flags | 8 /* Synthesized */);
-              fakeName.flowNode = node.flowNode;
-              const exprType2 = checkExpression(fakeName);
-              if (getConstraintOfTypeParameter(tp)) {
-                const narrowableConstraintType = mapType(tp.constraint, getBaseConstraintOrType);
-                if (narrowableConstraintType === exprType2) {
-                  return tp;
-                }
-              }
-              return exprType2;
-            }));
-            actualReturnType = instantiateNarrowType(
-              unwrappedReturnType,
-              narrowMapper,
-              /*mapper*/
-              void 0,
-              /*noTopLevel*/
-              true
-            );
-          }
-          links.contextualReturnType = actualReturnType;
-        }
-        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
           exprType,
           /*withAlias*/
@@ -78002,57 +77762,14 @@ function createTypeChecker(host) {
           node,
           Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
         ) : exprType;
-        if (actualReturnType) {
-          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, actualReturnType, node, node.expression);
+        if (unwrappedReturnType) {
+          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
         }
       }
     } else if (container.kind !== 175 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
-  function isQueryTypeParameter(typeParameter) {
-    if (typeParameter.exprName) {
-      return true;
-    }
-    if (isThisTypeParameter(typeParameter)) {
-      return false;
-    }
-    if (!typeParameter.symbol) {
-      return false;
-    }
-    const declaration = getDeclarationOfKind(typeParameter.symbol, 167 /* TypeParameter */);
-    const owner = getTypeParameterOwner(declaration);
-    if (!owner || !isFunctionLikeDeclaration(owner)) {
-      return false;
-    }
-    const references = [];
-    owner.parameters.forEach((parameter) => forEachChild(parameter, collectReferences));
-    if (references.length === 1) {
-      const reference = references[0];
-      let exprName;
-      if (isParameter(reference.parent) && reference.parent.parent === owner && (exprName = getNameOfDeclaration(reference.parent))) {
-        typeParameter.exprName = exprName;
-        return true;
-      }
-    }
-    return false;
-    function collectReferences(node) {
-      if (isFunctionLikeDeclaration(node.parent) && node === node.parent.body) {
-        return;
-      }
-      if (isNodeDescendantOf(node, owner.type)) {
-        return;
-      }
-      if (isTypeReferenceNode(node)) {
-        const type = getTypeFromTypeNode(node);
-        if (type.flags & 262144 /* TypeParameter */ && isTypeIdenticalTo(type, typeParameter)) {
-          references.push(node);
-        }
-        return;
-      }
-      forEachChild(node, collectReferences);
-    }
-  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 32768 /* AwaitContext */) {
@@ -80568,7 +80285,7 @@ function createTypeChecker(host) {
             /*contextFlags*/
             void 0
           );
-          const type = contextualType && getThisTypeFromContextualType(contextualType);
+          const type = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
           return type && !isTypeAny(type);
         }
       }