typescript 5.5.0-dev.20240402 → 5.5.0-dev.20240404

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240402`;
+var version = `${versionMajorMinor}.0-dev.20240404`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -43542,6 +43542,7 @@ function createTypeChecker(host) {
     isArgumentsSymbol: (symbol) => symbol === argumentsSymbol,
     isUnknownSymbol: (symbol) => symbol === unknownSymbol,
     getMergedSymbol,
+    symbolIsValue,
     getDiagnostics,
     getGlobalDiagnostics,
     getRecursionIdentity,
@@ -49110,68 +49111,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      let cleanup;
-      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && (some(expandedParams) || some(signature.typeParameters))) {
-        let pushFakeScope2 = function(kind2, addAll) {
-          Debug.assert(context.enclosingDeclaration);
-          let existingFakeScope;
-          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration;
-          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration.parent;
-          }
-          Debug.assertOptionalNode(existingFakeScope, isBlock);
-          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
-          let newLocals;
-          addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
-            }
-          });
-          if (!newLocals)
-            return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
-            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind2;
-            fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
-            context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
-            };
-          }
-        };
-        var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
-          "params",
-          (add) => {
-            for (const param of expandedParams) {
-              add(param.escapedName, param);
-            }
-          }
-        );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
-            "typeParams",
-            (add) => {
-              for (const typeParam of signature.typeParameters ?? emptyArray) {
-                const typeParamName = typeParameterToName(typeParam, context).escapedText;
-                add(typeParamName, typeParam.symbol);
-              }
-            }
-          );
-        }
-      }
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -49262,6 +49202,111 @@ function createTypeChecker(host) {
       cleanup == null ? void 0 : cleanup();
       return node;
     }
+    function isNewScopeNode(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
+    }
+    function getTypeParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
+    }
+    function getParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
+        getSignatureFromDeclaration(node),
+        /*skipUnionExpanding*/
+        true
+      )[0] : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters) {
+      let cleanup;
+      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+        let pushFakeScope2 = function(kind, addAll) {
+          Debug.assert(context.enclosingDeclaration);
+          let existingFakeScope;
+          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration;
+          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration.parent;
+          }
+          Debug.assertOptionalNode(existingFakeScope, isBlock);
+          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
+          let newLocals;
+          addAll((name, symbol) => {
+            if (!locals.has(name)) {
+              newLocals = append(newLocals, name);
+              locals.set(name, symbol);
+            }
+          });
+          if (!newLocals)
+            return;
+          const oldCleanup = cleanup;
+          function undo() {
+            forEach(newLocals, (s) => locals.delete(s));
+            oldCleanup == null ? void 0 : oldCleanup();
+          }
+          if (existingFakeScope) {
+            cleanup = undo;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              undo();
+            };
+          }
+        };
+        var pushFakeScope = pushFakeScope2;
+        pushFakeScope2(
+          "params",
+          (add) => {
+            for (const param of expandedParams ?? emptyArray) {
+              if (!forEach(param.declarations, (d) => {
+                if (isParameter(d) && isBindingPattern(d.name)) {
+                  bindPattern(d.name);
+                  return true;
+                }
+                return void 0;
+                function bindPattern(p) {
+                  forEach(p.elements, (e) => {
+                    switch (e.kind) {
+                      case 232 /* OmittedExpression */:
+                        return;
+                      case 208 /* BindingElement */:
+                        return bindElement(e);
+                      default:
+                        return Debug.assertNever(e);
+                    }
+                  });
+                }
+                function bindElement(e) {
+                  if (isBindingPattern(e.name)) {
+                    return bindPattern(e.name);
+                  }
+                  const symbol = getSymbolOfDeclaration(e);
+                  add(symbol.escapedName, symbol);
+                }
+              })) {
+                add(param.escapedName, param);
+              }
+            }
+          }
+        );
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+          pushFakeScope2(
+            "typeParams",
+            (add) => {
+              for (const typeParam of typeParameters ?? emptyArray) {
+                const typeParamName = typeParameterToName(typeParam, context).escapedText;
+                add(typeParamName, typeParam.symbol);
+              }
+            }
+          );
+        }
+        return cleanup;
+      }
+    }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
         return symbolToParameterDeclaration(signature.thisParameter, context);
@@ -49880,6 +49925,9 @@ function createTypeChecker(host) {
       if (initial.typeParameterSymbolList) {
         initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
       }
+      if (initial.typeParameterNamesByTextNextNameCount) {
+        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
+      }
       initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
       return initial;
     }
@@ -49887,7 +49935,16 @@ function createTypeChecker(host) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
-      return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
+      if (!(getObjectFlags(type) & 4 /* Reference */))
+        return true;
+      if (!isTypeReferenceNode(existing))
+        return true;
+      void getTypeFromTypeReference(existing);
+      const symbol = getNodeLinks(existing).resolvedSymbol;
+      const existingTarget = symbol && getDeclaredTypeOfSymbol(symbol);
+      if (!existingTarget || existingTarget !== type.target)
+        return true;
+      return length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
     }
     function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
       while (getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration) {
@@ -50012,6 +50069,22 @@ function createTypeChecker(host) {
       }
       return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
       function visitExistingNodeTreeSymbols(node) {
+        const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
+        const result = visitExistingNodeTreeSymbolsWorker(node);
+        onExitNewScope == null ? void 0 : onExitNewScope();
+        return result;
+      }
+      function onEnterNewScope(node) {
+        const oldContex = context;
+        context = cloneNodeBuilderContext(context);
+        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
+        return onExitNewScope;
+        function onExitNewScope() {
+          cleanup == null ? void 0 : cleanup();
+          context = oldContex;
+        }
+      }
+      function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
           return factory.createKeywordTypeNode(133 /* AnyKeyword */);
         }
@@ -50162,6 +50235,21 @@ function createTypeChecker(host) {
           setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone;
         }
+        if (isConditionalTypeNode(node)) {
+          const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
+          const disposeScope = onEnterNewScope(node);
+          const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
+          const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
+          disposeScope();
+          const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
+          return factory.updateConditionalTypeNode(
+            node,
+            checkType,
+            extendType,
+            trueType2,
+            falseType2
+          );
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -63377,6 +63465,9 @@ function createTypeChecker(host) {
       const resolved = resolveStructuredTypeMembers(type);
       return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
     }
+    if (type.flags & 33554432 /* Substitution */) {
+      return isWeakType(type.baseType);
+    }
     if (type.flags & 2097152 /* Intersection */) {
       return every(type.types, isWeakType);
     }
@@ -70345,7 +70436,11 @@ function createTypeChecker(host) {
       if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
         return true;
       }
-    } else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
+    }
+    if (targetType.flags & 33554432 /* Substitution */) {
+      return isKnownProperty(targetType.baseType, name, isComparingJsxAttributes);
+    }
+    if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
       for (const t of targetType.types) {
         if (isKnownProperty(t, name, isComparingJsxAttributes)) {
           return true;
@@ -70355,7 +70450,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isExcessPropertyCheckTarget(type) {
-    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
+    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 33554432 /* Substitution */ && isExcessPropertyCheckTarget(type.baseType) || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
   }
   function checkJsxExpression(node, checkMode) {
     checkGrammarJsxExpression(node);
@@ -74496,17 +74591,18 @@ function createTypeChecker(host) {
     const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
     const trueCondition = {
       flags: 32 /* TrueCondition */,
-      node: expr,
-      antecedent
+      antecedent,
+      node: expr
     };
     const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
     if (trueType2 === initType)
       return void 0;
     const falseCondition = {
-      ...trueCondition,
-      flags: 64 /* FalseCondition */
+      flags: 64 /* FalseCondition */,
+      antecedent,
+      node: expr
     };
-    const falseSubtype = getFlowTypeOfReference(param.name, trueType2, trueType2, func, falseCondition);
+    const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {

package/lib/typescript.d.ts

@@ -5793,61 +5793,6 @@ declare namespace ts {
         readonly moduleSpecifier: Expression;
         readonly attributes?: ImportAttributes;
     }
-    enum FlowFlags {
-        Unreachable = 1,
-        Start = 2,
-        BranchLabel = 4,
-        LoopLabel = 8,
-        Assignment = 16,
-        TrueCondition = 32,
-        FalseCondition = 64,
-        SwitchClause = 128,
-        ArrayMutation = 256,
-        Call = 512,
-        ReduceLabel = 1024,
-        Referenced = 2048,
-        Shared = 4096,
-        Label = 12,
-        Condition = 96,
-    }
-    type FlowNode = FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation | FlowCall | FlowReduceLabel;
-    interface FlowNodeBase {
-        flags: FlowFlags;
-        id?: number;
-    }
-    interface FlowStart extends FlowNodeBase {
-        node?: FunctionExpression | ArrowFunction | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration;
-    }
-    interface FlowLabel extends FlowNodeBase {
-        antecedents: FlowNode[] | undefined;
-    }
-    interface FlowAssignment extends FlowNodeBase {
-        node: Expression | VariableDeclaration | BindingElement;
-        antecedent: FlowNode;
-    }
-    interface FlowCall extends FlowNodeBase {
-        node: CallExpression;
-        antecedent: FlowNode;
-    }
-    interface FlowCondition extends FlowNodeBase {
-        node: Expression;
-        antecedent: FlowNode;
-    }
-    interface FlowSwitchClause extends FlowNodeBase {
-        switchStatement: SwitchStatement;
-        clauseStart: number;
-        clauseEnd: number;
-        antecedent: FlowNode;
-    }
-    interface FlowArrayMutation extends FlowNodeBase {
-        node: CallExpression | BinaryExpression;
-        antecedent: FlowNode;
-    }
-    interface FlowReduceLabel extends FlowNodeBase {
-        target: FlowLabel;
-        antecedents: FlowNode[];
-        antecedent: FlowNode;
-    }
     type FlowType = Type | IncompleteType;
     interface IncompleteType {
         flags: TypeFlags | 0;

package/lib/typescript.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240402`;
+var version = `${versionMajorMinor}.0-dev.20240404`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -48307,6 +48307,7 @@ function createTypeChecker(host) {
     isArgumentsSymbol: (symbol) => symbol === argumentsSymbol,
     isUnknownSymbol: (symbol) => symbol === unknownSymbol,
     getMergedSymbol,
+    symbolIsValue,
     getDiagnostics: getDiagnostics2,
     getGlobalDiagnostics,
     getRecursionIdentity,
@@ -53875,68 +53876,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      let cleanup;
-      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && (some(expandedParams) || some(signature.typeParameters))) {
-        let pushFakeScope2 = function(kind2, addAll) {
-          Debug.assert(context.enclosingDeclaration);
-          let existingFakeScope;
-          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration;
-          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration.parent;
-          }
-          Debug.assertOptionalNode(existingFakeScope, isBlock);
-          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
-          let newLocals;
-          addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
-            }
-          });
-          if (!newLocals)
-            return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
-            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind2;
-            fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
-            context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
-            };
-          }
-        };
-        var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
-          "params",
-          (add) => {
-            for (const param of expandedParams) {
-              add(param.escapedName, param);
-            }
-          }
-        );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
-            "typeParams",
-            (add) => {
-              for (const typeParam of signature.typeParameters ?? emptyArray) {
-                const typeParamName = typeParameterToName(typeParam, context).escapedText;
-                add(typeParamName, typeParam.symbol);
-              }
-            }
-          );
-        }
-      }
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -54027,6 +53967,111 @@ function createTypeChecker(host) {
       cleanup == null ? void 0 : cleanup();
       return node;
     }
+    function isNewScopeNode(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
+    }
+    function getTypeParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
+    }
+    function getParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
+        getSignatureFromDeclaration(node),
+        /*skipUnionExpanding*/
+        true
+      )[0] : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters) {
+      let cleanup;
+      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+        let pushFakeScope2 = function(kind, addAll) {
+          Debug.assert(context.enclosingDeclaration);
+          let existingFakeScope;
+          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration;
+          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration.parent;
+          }
+          Debug.assertOptionalNode(existingFakeScope, isBlock);
+          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
+          let newLocals;
+          addAll((name, symbol) => {
+            if (!locals.has(name)) {
+              newLocals = append(newLocals, name);
+              locals.set(name, symbol);
+            }
+          });
+          if (!newLocals)
+            return;
+          const oldCleanup = cleanup;
+          function undo() {
+            forEach(newLocals, (s) => locals.delete(s));
+            oldCleanup == null ? void 0 : oldCleanup();
+          }
+          if (existingFakeScope) {
+            cleanup = undo;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              undo();
+            };
+          }
+        };
+        var pushFakeScope = pushFakeScope2;
+        pushFakeScope2(
+          "params",
+          (add) => {
+            for (const param of expandedParams ?? emptyArray) {
+              if (!forEach(param.declarations, (d) => {
+                if (isParameter(d) && isBindingPattern(d.name)) {
+                  bindPattern(d.name);
+                  return true;
+                }
+                return void 0;
+                function bindPattern(p) {
+                  forEach(p.elements, (e) => {
+                    switch (e.kind) {
+                      case 232 /* OmittedExpression */:
+                        return;
+                      case 208 /* BindingElement */:
+                        return bindElement(e);
+                      default:
+                        return Debug.assertNever(e);
+                    }
+                  });
+                }
+                function bindElement(e) {
+                  if (isBindingPattern(e.name)) {
+                    return bindPattern(e.name);
+                  }
+                  const symbol = getSymbolOfDeclaration(e);
+                  add(symbol.escapedName, symbol);
+                }
+              })) {
+                add(param.escapedName, param);
+              }
+            }
+          }
+        );
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+          pushFakeScope2(
+            "typeParams",
+            (add) => {
+              for (const typeParam of typeParameters ?? emptyArray) {
+                const typeParamName = typeParameterToName(typeParam, context).escapedText;
+                add(typeParamName, typeParam.symbol);
+              }
+            }
+          );
+        }
+        return cleanup;
+      }
+    }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
         return symbolToParameterDeclaration(signature.thisParameter, context);
@@ -54645,6 +54690,9 @@ function createTypeChecker(host) {
       if (initial.typeParameterSymbolList) {
         initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
       }
+      if (initial.typeParameterNamesByTextNextNameCount) {
+        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
+      }
       initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
       return initial;
     }
@@ -54652,7 +54700,16 @@ function createTypeChecker(host) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
-      return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
+      if (!(getObjectFlags(type) & 4 /* Reference */))
+        return true;
+      if (!isTypeReferenceNode(existing))
+        return true;
+      void getTypeFromTypeReference(existing);
+      const symbol = getNodeLinks(existing).resolvedSymbol;
+      const existingTarget = symbol && getDeclaredTypeOfSymbol(symbol);
+      if (!existingTarget || existingTarget !== type.target)
+        return true;
+      return length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
     }
     function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
       while (getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration) {
@@ -54777,6 +54834,22 @@ function createTypeChecker(host) {
       }
       return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
       function visitExistingNodeTreeSymbols(node) {
+        const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
+        const result = visitExistingNodeTreeSymbolsWorker(node);
+        onExitNewScope == null ? void 0 : onExitNewScope();
+        return result;
+      }
+      function onEnterNewScope(node) {
+        const oldContex = context;
+        context = cloneNodeBuilderContext(context);
+        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
+        return onExitNewScope;
+        function onExitNewScope() {
+          cleanup == null ? void 0 : cleanup();
+          context = oldContex;
+        }
+      }
+      function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
           return factory.createKeywordTypeNode(133 /* AnyKeyword */);
         }
@@ -54927,6 +55000,21 @@ function createTypeChecker(host) {
           setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone2;
         }
+        if (isConditionalTypeNode(node)) {
+          const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
+          const disposeScope = onEnterNewScope(node);
+          const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
+          const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
+          disposeScope();
+          const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
+          return factory.updateConditionalTypeNode(
+            node,
+            checkType,
+            extendType,
+            trueType2,
+            falseType2
+          );
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -68142,6 +68230,9 @@ function createTypeChecker(host) {
       const resolved = resolveStructuredTypeMembers(type);
       return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
     }
+    if (type.flags & 33554432 /* Substitution */) {
+      return isWeakType(type.baseType);
+    }
     if (type.flags & 2097152 /* Intersection */) {
       return every(type.types, isWeakType);
     }
@@ -75110,7 +75201,11 @@ function createTypeChecker(host) {
       if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
         return true;
       }
-    } else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
+    }
+    if (targetType.flags & 33554432 /* Substitution */) {
+      return isKnownProperty(targetType.baseType, name, isComparingJsxAttributes);
+    }
+    if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
       for (const t of targetType.types) {
         if (isKnownProperty(t, name, isComparingJsxAttributes)) {
           return true;
@@ -75120,7 +75215,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isExcessPropertyCheckTarget(type) {
-    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
+    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 33554432 /* Substitution */ && isExcessPropertyCheckTarget(type.baseType) || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
   }
   function checkJsxExpression(node, checkMode) {
     checkGrammarJsxExpression(node);
@@ -79261,17 +79356,18 @@ function createTypeChecker(host) {
     const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
     const trueCondition = {
       flags: 32 /* TrueCondition */,
-      node: expr,
-      antecedent
+      antecedent,
+      node: expr
     };
     const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
     if (trueType2 === initType)
       return void 0;
     const falseCondition = {
-      ...trueCondition,
-      flags: 64 /* FalseCondition */
+      flags: 64 /* FalseCondition */,
+      antecedent,
+      node: expr
     };
-    const falseSubtype = getFlowTypeOfReference(param.name, trueType2, trueType2, func, falseCondition);
+    const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
@@ -150175,7 +150271,8 @@ function canConvertImportDeclarationForSpecifier(specifier, sourceFile, program)
   const checker = program.getTypeChecker();
   for (const specifier2 of nonTypeOnlySpecifiers) {
     const isUsedAsValue = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(specifier2.name, checker, sourceFile, (usage) => {
-      return !isValidTypeOnlyAliasUseSite(usage);
+      const symbol = checker.getSymbolAtLocation(usage);
+      return !!symbol && checker.symbolIsValue(symbol) || !isValidTypeOnlyAliasUseSite(usage);
     });
     if (isUsedAsValue) {
       return false;
@@ -173560,7 +173657,8 @@ var SmartIndenter;
         return childKind !== 290 /* JsxClosingFragment */;
       case 193 /* IntersectionType */:
       case 192 /* UnionType */:
-        if (childKind === 187 /* TypeLiteral */ || childKind === 189 /* TupleType */) {
+      case 238 /* SatisfiesExpression */:
+        if (childKind === 187 /* TypeLiteral */ || childKind === 189 /* TupleType */ || childKind === 200 /* MappedType */) {
           return false;
         }
         break;

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.5.0-dev.20240402",
+    "version": "5.5.0-dev.20240404",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -64,7 +64,6 @@
         "eslint-formatter-autolinkable-stylish": "^1.3.0",
         "eslint-plugin-local": "^4.2.1",
         "eslint-plugin-no-null": "^1.0.2",
-        "eslint-plugin-simple-import-sort": "^12.0.0",
         "fast-xml-parser": "^4.3.6",
         "glob": "^10.3.10",
         "hereby": "^1.8.9",
@@ -112,5 +111,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "824cd6eb314bdcb8b7bde158025c82ebc014db0a"
+    "gitHead": "4a5f0f2b78d36afee184ec52419559a390cf17bd"
 }