@typescript-deploys/pr-build 5.4.0-pr-56034-9 → 5.4.0-pr-49218-45

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240108`;
+var version = `${versionMajorMinor}.0-insiders.20240110`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -12673,7 +12673,7 @@ function isPartOfTypeNode(node) {
     case 116 /* VoidKeyword */:
       return node.parent.kind !== 222 /* VoidExpression */;
     case 233 /* ExpressionWithTypeArguments */:
-      return isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+      return isPartOfTypeExpressionWithTypeArguments(node);
     case 168 /* TypeParameter */:
       return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */;
     case 80 /* Identifier */:
@@ -12698,7 +12698,7 @@ function isPartOfTypeNode(node) {
       }
       switch (parent.kind) {
         case 233 /* ExpressionWithTypeArguments */:
-          return isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+          return isPartOfTypeExpressionWithTypeArguments(parent);
         case 168 /* TypeParameter */:
           return node === parent.constraint;
         case 352 /* JSDocTemplateTag */:
@@ -12732,6 +12732,9 @@ function isPartOfTypeNode(node) {
   }
   return false;
 }
+function isPartOfTypeExpressionWithTypeArguments(node) {
+  return isJSDocImplementsTag(node.parent) || isJSDocAugmentsTag(node.parent) || isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+}
 function forEachReturnStatement(body, visitor) {
   return traverse(body);
   function traverse(node) {
@@ -16070,7 +16073,7 @@ function Symbol4(flags, name) {
   this.exportSymbol = void 0;
   this.constEnumOnlyModule = void 0;
   this.isReferenced = void 0;
-  this.isAssigned = void 0;
+  this.lastAssignmentPos = void 0;
   this.links = void 0;
 }
 function Type3(checker, flags) {
@@ -17495,10 +17498,6 @@ function isInfinityOrNaNString(name) {
 function isCatchClauseVariableDeclaration(node) {
   return node.kind === 260 /* VariableDeclaration */ && node.parent.kind === 299 /* CatchClause */;
 }
-function isParameterOrCatchClauseVariable(symbol) {
-  const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
-  return !!declaration && (isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
-}
 function isFunctionExpressionOrArrowFunction(node) {
   return node.kind === 218 /* FunctionExpression */ || node.kind === 219 /* ArrowFunction */;
 }
@@ -17672,9 +17671,6 @@ var stringReplace = String.prototype.replace;
 function replaceFirstStar(s, replacement) {
   return stringReplace.call(s, "*", replacement);
 }
-function getNameFromImportAttribute(node) {
-  return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
-}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -44288,6 +44284,14 @@ function createTypeChecker(host) {
     emptyArray,
     emptyArray
   );
+  var resolvingApparentMappedType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    emptyArray
+  );
   var markerSuperType = createTypeParameter();
   var markerSubType = createTypeParameter();
   markerSubType.constraint = markerSuperType;
@@ -44442,7 +44446,6 @@ function createTypeChecker(host) {
   var deferredGlobalImportMetaType;
   var deferredGlobalImportMetaExpressionType;
   var deferredGlobalImportCallOptionsType;
-  var deferredGlobalImportAttributesType;
   var deferredGlobalDisposableType;
   var deferredGlobalAsyncDisposableType;
   var deferredGlobalExtractSymbol;
@@ -47338,29 +47341,7 @@ function createTypeChecker(host) {
   function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
     const container = getParentOfSymbol(symbol);
     if (container && !(symbol.flags & 262144 /* TypeParameter */)) {
-      const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
-      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
-      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
-      if (enclosingDeclaration && container.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
-        container,
-        enclosingDeclaration,
-        1920 /* Namespace */,
-        /*useOnlyExternalAliasing*/
-        false
-      )) {
-        return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
-      }
-      const firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) && container.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
-        return forEachEntry(t, (s) => {
-          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) {
-            return s;
-          }
-        });
-      }) : void 0;
-      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container] : [...additionalContainers, container];
-      res = append(res, objectLiteralContainer);
-      res = addRange(res, reexportContainers);
-      return res;
+      return getWithAlternativeContainers(container);
     }
     const candidates = mapDefined(symbol.declarations, (d) => {
       if (!isAmbientModule(d) && d.parent) {
@@ -47382,7 +47363,40 @@ function createTypeChecker(host) {
     if (!length(candidates)) {
       return void 0;
     }
-    return mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    const containers = mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    let bestContainers = [];
+    let alternativeContainers = [];
+    for (const container2 of containers) {
+      const [bestMatch, ...rest] = getWithAlternativeContainers(container2);
+      bestContainers = append(bestContainers, bestMatch);
+      alternativeContainers = addRange(alternativeContainers, rest);
+    }
+    return concatenate(bestContainers, alternativeContainers);
+    function getWithAlternativeContainers(container2) {
+      const additionalContainers = mapDefined(container2.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
+      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
+      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container2, meaning);
+      if (enclosingDeclaration && container2.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
+        container2,
+        enclosingDeclaration,
+        1920 /* Namespace */,
+        /*useOnlyExternalAliasing*/
+        false
+      )) {
+        return append(concatenate(concatenate([container2], additionalContainers), reexportContainers), objectLiteralContainer);
+      }
+      const firstVariableMatch = !(container2.flags & getQualifiedLeftMeaning(meaning)) && container2.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container2).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
+        return forEachEntry(t, (s) => {
+          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container2)) {
+            return s;
+          }
+        });
+      }) : void 0;
+      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container2] : [...additionalContainers, container2];
+      res = append(res, objectLiteralContainer);
+      res = addRange(res, reexportContainers);
+      return res;
+    }
     function fileSymbolIfFileSymbolExportEqualsContainer(d) {
       return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
     }
@@ -47420,6 +47434,13 @@ function createTypeChecker(host) {
     });
   }
   function getSymbolIfSameReference(s1, s2) {
+    var _a, _b;
+    if (s1.flags & 524288 /* TypeAlias */ && ((_a = s2.declarations) == null ? void 0 : _a.find(isTypeAlias))) {
+      s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
+    }
+    if (s2.flags & 524288 /* TypeAlias */ && ((_b = s1.declarations) == null ? void 0 : _b.find(isTypeAlias))) {
+      s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
+    }
     if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
       return s1;
     }
@@ -52743,24 +52764,6 @@ function createTypeChecker(host) {
       0 /* Normal */
     ), declaration, reportErrors2);
   }
-  function getTypeFromImportAttributes(node) {
-    const links = getNodeLinks(node);
-    if (!links.resolvedType) {
-      const symbol = createSymbol(4096 /* ObjectLiteral */, "__importAttributes" /* ImportAttributes */);
-      const members = createSymbolTable();
-      forEach(node.elements, (attr) => {
-        const member = createSymbol(4 /* Property */, getNameFromImportAttribute(attr));
-        member.parent = symbol;
-        member.links.type = checkImportAttribute(attr);
-        member.links.target = member;
-        members.set(member.escapedName, member);
-      });
-      const type = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
-      type.objectFlags |= 128 /* ObjectLiteral */ | 262144 /* NonInferrableType */;
-      links.resolvedType = type;
-    }
-    return links.resolvedType;
-  }
   function isGlobalSymbolConstructor(node) {
     const symbol = getSymbolOfNode(node);
     const globalSymbol = getGlobalESSymbolConstructorTypeSymbol(
@@ -55176,14 +55179,30 @@ function createTypeChecker(host) {
     return !!(typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default));
   }
   function getApparentTypeOfMappedType(type) {
-    return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
+    if (type.resolvedApparentType) {
+      if (type.resolvedApparentType === resolvingApparentMappedType) {
+        return type.resolvedApparentType = type;
+      }
+      return type.resolvedApparentType;
+    }
+    type.resolvedApparentType = resolvingApparentMappedType;
+    return type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type);
   }
   function getResolvedApparentTypeOfMappedType(type) {
-    const typeVariable = getHomomorphicTypeVariable(type);
-    if (typeVariable && !type.declaration.nameType) {
-      const constraint = getConstraintOfTypeParameter(typeVariable);
+    const mappedType = type.target || type;
+    const typeVariable = getHomomorphicTypeVariable(mappedType);
+    if (typeVariable && !mappedType.declaration.nameType) {
+      let constraint;
+      if (!type.target) {
+        constraint = getConstraintOfTypeParameter(typeVariable);
+      } else {
+        const modifiersConstraint = getConstraintOfType(getModifiersTypeFromMappedType(type));
+        if (modifiersConstraint) {
+          constraint = getApparentType(modifiersConstraint);
+        }
+      }
       if (constraint && everyType(constraint, isArrayOrTupleType)) {
-        return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
+        return instantiateType(mappedType, prependTypeMapping(typeVariable, constraint, mappedType.mapper));
       }
     }
     return type;
@@ -55274,6 +55293,7 @@ function createTypeChecker(host) {
         clone2.parent = (_c = (_b = singleProp.valueDeclaration) == null ? void 0 : _b.symbol) == null ? void 0 : _c.parent;
         clone2.links.containingType = containingType;
         clone2.links.mapper = links == null ? void 0 : links.mapper;
+        clone2.links.writeType = getWriteTypeOfSymbol(singleProp);
         return clone2;
       } else {
         return singleProp;
@@ -56742,14 +56762,6 @@ function createTypeChecker(host) {
       reportErrors2
     )) || emptyObjectType;
   }
-  function getGlobalImportAttributesType(reportErrors2) {
-    return deferredGlobalImportAttributesType || (deferredGlobalImportAttributesType = getGlobalType(
-      "ImportAttributes",
-      /*arity*/
-      0,
-      reportErrors2
-    )) || emptyObjectType;
-  }
   function getGlobalESSymbolConstructorSymbol(reportErrors2) {
     return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors2));
   }
@@ -60517,7 +60529,37 @@ function createTypeChecker(host) {
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
       const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
-      const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+      let targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+      if (i === restIndex && targetType && sourceType && isTupleType(sourceType)) {
+        targetType = mapType(targetType, (t) => {
+          if (!isTupleType(t) || // When both sides are tuples of the same structure, we don't want to "propagate" types from elements of variable positions
+          // to the following positions as that would disallow signatures of the exact same structures when trailing fixed elements are involved:
+          //
+          // let fn: (...rest: [...string[], number]) => void = (...rest: [...string[], number]) => {}; // ok
+          //
+          // Since we want to allow contextual types to flow into paremeters, we don't need to differentiate between rest and variadic elements
+          // as that doesn't affect the contextual type of the parameter
+          isTupleTypeStructureMatching(sourceType, t, 2 /* MatchVariable */)) {
+            return t;
+          }
+          const elementTypes = [];
+          const elementFlags = [];
+          const sourceArity = getTypeReferenceArity(sourceType);
+          const targetArity = getTypeReferenceArity(t);
+          for (let i2 = 0; i2 < sourceArity; i2++) {
+            if (i2 >= targetArity) {
+              if (sourceType.target.elementFlags[i2] & 3 /* Fixed */) {
+                elementTypes.push(undefinedType);
+                elementFlags.push(sourceType.target.elementFlags[i2]);
+              }
+              continue;
+            }
+            elementTypes.push(getTupleElementType(t, i2));
+            elementFlags.push(sourceType.target.elementFlags[i2]);
+          }
+          return createTupleType(elementTypes, elementFlags);
+        });
+      }
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(source, i) ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(target, i) ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
@@ -61907,6 +61949,18 @@ function createTypeChecker(host) {
       }
       return result2;
     }
+    function getApparentMappedTypeKeys(nameType, targetType) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
+      const mappedKeys = [];
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
+        modifiersType,
+        8576 /* StringOrNumberLiteralOrUnique */,
+        /*stringsOnly*/
+        false,
+        (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
+      );
+      return getUnionType(mappedKeys);
+    }
     function structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo) {
       let result2;
       let originalErrorInfo;
@@ -62089,16 +62143,8 @@ function createTypeChecker(host) {
             const constraintType = getConstraintTypeFromMappedType(targetType);
             let targetKeys;
             if (nameType && isMappedTypeWithKeyofConstraintDeclaration(targetType)) {
-              const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
-              const mappedKeys = [];
-              forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
-                modifiersType,
-                8576 /* StringOrNumberLiteralOrUnique */,
-                /*stringsOnly*/
-                false,
-                (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
-              );
-              targetKeys = getUnionType([...mappedKeys, nameType]);
+              const mappedKeys = getApparentMappedTypeKeys(nameType, targetType);
+              targetKeys = getUnionType([mappedKeys, nameType]);
             } else {
               targetKeys = nameType || constraintType;
             }
@@ -62269,9 +62315,18 @@ function createTypeChecker(host) {
           }
         }
       } else if (sourceFlags & 4194304 /* Index */) {
-        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2)) {
+        const isDeferredMappedIndex = shouldDeferIndexType(source2.type, source2.indexFlags) && getObjectFlags(source2.type) & 32 /* Mapped */;
+        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2 && !isDeferredMappedIndex)) {
           return result2;
         }
+        if (isDeferredMappedIndex) {
+          const mappedType = source2.type;
+          const nameType = getNameTypeFromMappedType(mappedType);
+          const sourceMappedKeys = nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType) ? getApparentMappedTypeKeys(nameType, mappedType) : nameType || getConstraintTypeFromMappedType(mappedType);
+          if (result2 = isRelatedTo(sourceMappedKeys, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
         if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
           const constraint = getBaseConstraintOfType(source2);
@@ -63761,8 +63816,11 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function isTupleTypeStructureMatching(t1, t2) {
-    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
+  function isTupleTypeStructureMatching(t1, t2, tupleStructureComparisonKind) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f1, i) => {
+      const f2 = t2.target.elementFlags[i];
+      return f1 === f2 || !!(tupleStructureComparisonKind & 1 /* MatchFixed */ && f1 & 3 /* Fixed */ && f2 & 3 /* Fixed */) || !!(tupleStructureComparisonKind & 2 /* MatchVariable */ && f1 & 12 /* Variable */ && f2 & 12 /* Variable */);
+    });
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -64970,7 +65028,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -66208,7 +66266,7 @@ function createTypeChecker(host) {
       case 80 /* Identifier */:
         if (!isThisInTypeQuery(node)) {
           const symbol = getResolvedSymbol(node);
-          return isConstantVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
+          return isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol);
         }
         break;
       case 211 /* PropertyAccessExpression */:
@@ -66217,7 +66275,7 @@ function createTypeChecker(host) {
       case 206 /* ObjectBindingPattern */:
       case 207 /* ArrayBindingPattern */:
         const rootDeclaration = getRootDeclaration(node.parent);
-        return isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
+        return isParameter(rootDeclaration) || isCatchClauseVariableDeclaration(rootDeclaration) ? !isSomeSymbolAssigned(rootDeclaration) : isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
     }
     return false;
   }
@@ -67298,10 +67356,17 @@ function createTypeChecker(host) {
     return findAncestor(node.parent, (node2) => isFunctionLike(node2) && !getImmediatelyInvokedFunctionExpression(node2) || node2.kind === 268 /* ModuleBlock */ || node2.kind === 312 /* SourceFile */ || node2.kind === 172 /* PropertyDeclaration */);
   }
   function isSymbolAssigned(symbol) {
-    if (!symbol.valueDeclaration) {
+    return !isPastLastAssignment(
+      symbol,
+      /*location*/
+      void 0
+    );
+  }
+  function isPastLastAssignment(symbol, location) {
+    const parent = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile);
+    if (!parent) {
       return false;
     }
-    const parent = getRootDeclaration(symbol.valueDeclaration).parent;
     const links = getNodeLinks(parent);
     if (!(links.flags & 131072 /* AssignmentsMarked */)) {
       links.flags |= 131072 /* AssignmentsMarked */;
@@ -67309,7 +67374,7 @@ function createTypeChecker(host) {
         markNodeAssignments(parent);
       }
     }
-    return symbol.isAssigned || false;
+    return !symbol.lastAssignmentPos || location && symbol.lastAssignmentPos < location.pos;
   }
   function isSomeSymbolAssigned(rootDeclaration) {
     Debug.assert(isVariableDeclaration(rootDeclaration) || isParameter(rootDeclaration));
@@ -67322,23 +67387,81 @@ function createTypeChecker(host) {
     return some(node.elements, (e) => e.kind !== 232 /* OmittedExpression */ && isSomeSymbolAssignedWorker(e.name));
   }
   function hasParentWithAssignmentsMarked(node) {
-    return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 131072 /* AssignmentsMarked */));
+    return !!findAncestor(node.parent, (node2) => isFunctionOrSourceFile(node2) && !!(getNodeLinks(node2).flags & 131072 /* AssignmentsMarked */));
+  }
+  function isFunctionOrSourceFile(node) {
+    return isFunctionLikeDeclaration(node) || isSourceFile(node);
   }
   function markNodeAssignments(node) {
-    if (node.kind === 80 /* Identifier */) {
-      if (isAssignmentTarget(node)) {
-        const symbol = getResolvedSymbol(node);
-        if (isParameterOrCatchClauseVariable(symbol)) {
-          symbol.isAssigned = true;
+    switch (node.kind) {
+      case 80 /* Identifier */:
+        if (isAssignmentTarget(node)) {
+          const symbol = getResolvedSymbol(node);
+          if (isParameterOrMutableLocalVariable(symbol) && symbol.lastAssignmentPos !== Number.MAX_VALUE) {
+            const referencingFunction = findAncestor(node, isFunctionOrSourceFile);
+            const declaringFunction = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile);
+            symbol.lastAssignmentPos = referencingFunction === declaringFunction ? extendAssignmentPosition(node, symbol.valueDeclaration) : Number.MAX_VALUE;
+          }
         }
+        return;
+      case 281 /* ExportSpecifier */:
+        const exportDeclaration = node.parent.parent;
+        if (!node.isTypeOnly && !exportDeclaration.isTypeOnly && !exportDeclaration.moduleSpecifier) {
+          const symbol = resolveEntityName(
+            node.propertyName || node.name,
+            111551 /* Value */,
+            /*ignoreErrors*/
+            true,
+            /*dontResolveAlias*/
+            true
+          );
+          if (symbol && isParameterOrMutableLocalVariable(symbol)) {
+            symbol.lastAssignmentPos = Number.MAX_VALUE;
+          }
+        }
+        return;
+      case 264 /* InterfaceDeclaration */:
+      case 265 /* TypeAliasDeclaration */:
+      case 266 /* EnumDeclaration */:
+        return;
+    }
+    if (isTypeNode(node)) {
+      return;
+    }
+    forEachChild(node, markNodeAssignments);
+  }
+  function extendAssignmentPosition(node, declaration) {
+    let pos = node.pos;
+    while (node && node.pos > declaration.pos) {
+      switch (node.kind) {
+        case 243 /* VariableStatement */:
+        case 244 /* ExpressionStatement */:
+        case 245 /* IfStatement */:
+        case 246 /* DoStatement */:
+        case 247 /* WhileStatement */:
+        case 248 /* ForStatement */:
+        case 249 /* ForInStatement */:
+        case 250 /* ForOfStatement */:
+        case 254 /* WithStatement */:
+        case 255 /* SwitchStatement */:
+        case 258 /* TryStatement */:
+        case 263 /* ClassDeclaration */:
+          pos = node.end;
       }
-    } else {
-      forEachChild(node, markNodeAssignments);
+      node = node.parent;
     }
+    return pos;
   }
   function isConstantVariable(symbol) {
     return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */) !== 0;
   }
+  function isParameterOrMutableLocalVariable(symbol) {
+    const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
+    return !!declaration && (isParameter(declaration) || isVariableDeclaration(declaration) && (isCatchClause(declaration.parent) || isMutableLocalVariableDeclaration(declaration)));
+  }
+  function isMutableLocalVariableDeclaration(declaration) {
+    return !!(declaration.parent.flags & 1 /* Let */) && !(getCombinedModifierFlags(declaration) & 32 /* Export */ || declaration.parent.parent.kind === 243 /* VariableStatement */ && isGlobalSourceFile(declaration.parent.parent.parent));
+  }
   function parameterInitializerContainsUndefined(declaration) {
     const links = getNodeLinks(declaration);
     if (links.parameterInitializerContainsUndefined === void 0) {
@@ -67587,7 +67710,7 @@ function createTypeChecker(host) {
     const isModuleExports = symbol.flags & 134217728 /* ModuleExports */;
     const typeIsAutomatic = type === autoType || type === autoArrayType;
     const isAutomaticTypeInNonNull = typeIsAutomatic && node.parent.kind === 235 /* NonNullExpression */;
-    while (flowContainer !== declarationContainer && (flowContainer.kind === 218 /* FunctionExpression */ || flowContainer.kind === 219 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameter2 && !isSymbolAssigned(localOrExportSymbol))) {
+    while (flowContainer !== declarationContainer && (flowContainer.kind === 218 /* FunctionExpression */ || flowContainer.kind === 219 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameterOrMutableLocalVariable(localOrExportSymbol) && isPastLastAssignment(localOrExportSymbol, node))) {
       flowContainer = getControlFlowContainer(flowContainer);
     }
     const assumeInitialized = isParameter2 || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */;
@@ -68858,8 +68981,6 @@ function createTypeChecker(host) {
       case 286 /* JsxOpeningElement */:
       case 285 /* JsxSelfClosingElement */:
         return getContextualJsxElementAttributesType(parent, contextFlags);
-      case 301 /* ImportAttribute */:
-        return getContextualImportAttributeType(parent);
     }
     return void 0;
   }
@@ -68907,12 +69028,6 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getContextualImportAttributeType(node) {
-    return getTypeOfPropertyOfContextualType(getGlobalImportAttributesType(
-      /*reportErrors*/
-      false
-    ), getNameFromImportAttribute(node));
-  }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
       const index = findContextualNode(
@@ -80998,13 +81113,6 @@ function createTypeChecker(host) {
     var _a;
     const node = declaration.attributes;
     if (node) {
-      const importAttributesType = getGlobalImportAttributesType(
-        /*reportErrors*/
-        true
-      );
-      if (importAttributesType !== emptyObjectType) {
-        checkTypeAssignableTo(getTypeFromImportAttributes(node), getNullableType(importAttributesType, 32768 /* Undefined */), node);
-      }
       const validForTypeAttributes = isExclusivelyTypeOnlyImportOrExport(declaration);
       const override = getResolutionModeOverride(node, validForTypeAttributes ? grammarErrorOnNode : void 0);
       const isImportAttributes2 = declaration.attributes.token === 118 /* WithKeyword */;
@@ -81024,9 +81132,6 @@ function createTypeChecker(host) {
       }
     }
   }
-  function checkImportAttribute(node) {
-    return getRegularTypeOfLiteralType(checkExpressionCached(node.value));
-  }
   function checkImportDeclaration(node) {
     if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
       return;
@@ -82442,12 +82547,6 @@ function createTypeChecker(host) {
     if (isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
       return checkMetaPropertyKeyword(node.parent);
     }
-    if (isImportAttributes(node)) {
-      return getGlobalImportAttributesType(
-        /*reportErrors*/
-        false
-      );
-    }
     return errorType;
   }
   function getTypeOfAssignmentPattern(expr) {
@@ -113470,7 +113569,14 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function willEmitLeadingNewLine(node) {
     if (!currentSourceFile)
       return false;
-    if (some(getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
+    const leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+    if (leadingCommentRanges) {
+      const parseNode = getParseTreeNode(node);
+      if (parseNode && isParenthesizedExpression(parseNode.parent)) {
+        return true;
+      }
+    }
+    if (some(leadingCommentRanges, commentWillEmitNewLine))
       return true;
     if (some(getSyntheticLeadingComments(node), commentWillEmitNewLine))
       return true;