@typescript-deploys/pr-build 5.5.0-pr-57403-12 → 5.5.0-pr-57465-17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/tsc.js CHANGED
@@ -3708,7 +3708,6 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
3708
3708
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
3709
3709
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
3710
3710
  ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
3711
- ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
3712
3711
  ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
3713
3712
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
3714
3713
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -48775,7 +48774,7 @@ function createTypeChecker(host) {
48775
48774
  }
48776
48775
  const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
48777
48776
  if (some(abstractSignatures)) {
48778
- const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
48777
+ const types = map(abstractSignatures, getOrCreateTypeFromSignature);
48779
48778
  const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
48780
48779
  // the logic in `createTypeNodesFromResolvedType`.
48781
48780
  (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -56017,7 +56016,15 @@ function createTypeChecker(host) {
56017
56016
  jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
56018
56017
  }
56019
56018
  }
56020
- signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
56019
+ if (type || jsdocPredicate) {
56020
+ signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
56021
+ } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
56022
+ const { declaration } = signature;
56023
+ signature.resolvedTypePredicate = noTypePredicate;
56024
+ signature.resolvedTypePredicate = getTypePredicateFromBody(declaration, signature) || noTypePredicate;
56025
+ } else {
56026
+ signature.resolvedTypePredicate = noTypePredicate;
56027
+ }
56021
56028
  }
56022
56029
  Debug.assert(!!signature.resolvedTypePredicate);
56023
56030
  }
@@ -56169,12 +56176,6 @@ function createTypeChecker(host) {
56169
56176
  isInJSFile(signature.declaration)
56170
56177
  );
56171
56178
  }
56172
- function getImplementationSignature(signature) {
56173
- return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
56174
- }
56175
- function createImplementationSignature(signature) {
56176
- return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
56177
- }
56178
56179
  function getBaseSignature(signature) {
56179
56180
  const typeParameters = signature.typeParameters;
56180
56181
  if (typeParameters) {
@@ -56197,22 +56198,12 @@ function createTypeChecker(host) {
56197
56198
  }
56198
56199
  return signature;
56199
56200
  }
56200
- function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
56201
+ function getOrCreateTypeFromSignature(signature) {
56201
56202
  var _a;
56202
56203
  if (!signature.isolatedSignatureType) {
56203
56204
  const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
56204
56205
  const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
56205
- const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
56206
- if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
56207
- type.symbol.declarations = [signature.declaration];
56208
- type.symbol.valueDeclaration = signature.declaration;
56209
- }
56210
- outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
56211
- signature.declaration,
56212
- /*includeThisTypes*/
56213
- true
56214
- ));
56215
- type.outerTypeParameters = outerTypeParameters;
56206
+ const type = createObjectType(16 /* Anonymous */);
56216
56207
  type.members = emptySymbols;
56217
56208
  type.properties = emptyArray;
56218
56209
  type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -59605,7 +59596,7 @@ function createTypeChecker(host) {
59605
59596
  const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
59606
59597
  const links = getNodeLinks(declaration);
59607
59598
  const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
59608
- let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
59599
+ let typeParameters = links.outerTypeParameters;
59609
59600
  if (!typeParameters) {
59610
59601
  let outerTypeParameters = getOuterTypeParameters(
59611
59602
  declaration,
@@ -59786,9 +59777,6 @@ function createTypeChecker(host) {
59786
59777
  if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
59787
59778
  result.node = type.node;
59788
59779
  }
59789
- if (type.objectFlags & 134217728 /* SingleSignatureType */) {
59790
- result.outerTypeParameters = type.outerTypeParameters;
59791
- }
59792
59780
  result.target = type;
59793
59781
  result.mapper = mapper;
59794
59782
  result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -64409,7 +64397,7 @@ function createTypeChecker(host) {
64409
64397
  if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
64410
64398
  return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
64411
64399
  }
64412
- const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
64400
+ const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
64413
64401
  if (type.flags & 3899393 /* ObjectFlagsType */) {
64414
64402
  type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
64415
64403
  }
@@ -64691,9 +64679,6 @@ function createTypeChecker(host) {
64691
64679
  pos = p;
64692
64680
  }
64693
64681
  }
64694
- function isTupleOfSelf(typeParameter, type) {
64695
- return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
64696
- }
64697
64682
  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
64698
64683
  let bivariant = false;
64699
64684
  let propagationType;
@@ -64779,9 +64764,6 @@ function createTypeChecker(host) {
64779
64764
  inference.priority = priority;
64780
64765
  }
64781
64766
  if (priority === inference.priority) {
64782
- if (isTupleOfSelf(inference.typeParameter, candidate)) {
64783
- return;
64784
- }
64785
64767
  if (contravariant && !bivariant) {
64786
64768
  if (!contains(inference.contraCandidates, candidate)) {
64787
64769
  inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -65348,7 +65330,9 @@ function createTypeChecker(host) {
65348
65330
  inferredType = silentNeverType;
65349
65331
  } else {
65350
65332
  const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
65351
- inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
65333
+ if (defaultType) {
65334
+ inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
65335
+ }
65352
65336
  }
65353
65337
  } else {
65354
65338
  inferredType = getTypeFromInference(inference);
@@ -71736,7 +71720,7 @@ function createTypeChecker(host) {
71736
71720
  void 0,
71737
71721
  checkMode
71738
71722
  );
71739
- const checkArgType = instantiateType(checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType, signature.mapper);
71723
+ const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
71740
71724
  const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
71741
71725
  if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
71742
71726
  Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -72280,16 +72264,13 @@ function createTypeChecker(host) {
72280
72264
  return candidate;
72281
72265
  }
72282
72266
  for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
72283
- let candidate = candidates2[candidateIndex];
72267
+ const candidate = candidates2[candidateIndex];
72284
72268
  if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
72285
72269
  continue;
72286
72270
  }
72287
72271
  let checkCandidate;
72288
72272
  let inferenceContext;
72289
72273
  if (candidate.typeParameters) {
72290
- if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
72291
- candidate = getImplementationSignature(candidate);
72292
- }
72293
72274
  let typeArgumentTypes;
72294
72275
  if (some(typeArguments)) {
72295
72276
  typeArgumentTypes = checkTypeArguments(
@@ -72309,7 +72290,7 @@ function createTypeChecker(host) {
72309
72290
  /*flags*/
72310
72291
  isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
72311
72292
  );
72312
- typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
72293
+ typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
72313
72294
  argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
72314
72295
  }
72315
72296
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -72337,7 +72318,7 @@ function createTypeChecker(host) {
72337
72318
  if (argCheckMode) {
72338
72319
  argCheckMode = 0 /* Normal */;
72339
72320
  if (inferenceContext) {
72340
- const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
72321
+ const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
72341
72322
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
72342
72323
  if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
72343
72324
  candidateForArgumentArityError = checkCandidate;
@@ -74452,6 +74433,89 @@ function createTypeChecker(host) {
74452
74433
  return false;
74453
74434
  }
74454
74435
  }
74436
+ function getTypePredicateFromBody(func, _sig) {
74437
+ const functionFlags = getFunctionFlags(func);
74438
+ if (functionFlags !== 0 /* Normal */)
74439
+ return void 0;
74440
+ let singleReturn;
74441
+ if (func.body && func.body.kind !== 241 /* Block */) {
74442
+ singleReturn = func.body;
74443
+ } else {
74444
+ if (functionHasImplicitReturn(func))
74445
+ return void 0;
74446
+ const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
74447
+ if (singleReturn || !returnStatement.expression)
74448
+ return true;
74449
+ singleReturn = returnStatement.expression;
74450
+ });
74451
+ if (bailedEarly || !singleReturn)
74452
+ return void 0;
74453
+ }
74454
+ const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
74455
+ if (predicate) {
74456
+ const [i, type] = predicate;
74457
+ const param = func.parameters[i];
74458
+ if (isIdentifier(param.name)) {
74459
+ return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
74460
+ }
74461
+ }
74462
+ return void 0;
74463
+ function checkIfExpressionRefinesAnyParameter(expr) {
74464
+ expr = skipParentheses(
74465
+ expr,
74466
+ /*excludeJSDocTypeAssertions*/
74467
+ true
74468
+ );
74469
+ const type = checkExpressionCached(expr, 64 /* TypeOnly */);
74470
+ if (type !== booleanType || !func.body)
74471
+ return void 0;
74472
+ return forEach(func.parameters, (param, i) => {
74473
+ const initType = getSymbolLinks(param.symbol).type;
74474
+ if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
74475
+ return;
74476
+ }
74477
+ const trueType2 = checkIfExpressionRefinesParameter(
74478
+ expr,
74479
+ param,
74480
+ initType,
74481
+ /*forceFullCheck*/
74482
+ false
74483
+ );
74484
+ if (trueType2) {
74485
+ const trueSubtype = checkIfExpressionRefinesParameter(
74486
+ expr,
74487
+ param,
74488
+ trueType2,
74489
+ /*forceFullCheck*/
74490
+ true
74491
+ );
74492
+ if (trueSubtype) {
74493
+ return [i, trueType2];
74494
+ }
74495
+ }
74496
+ });
74497
+ }
74498
+ function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
74499
+ const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
74500
+ const trueCondition = {
74501
+ flags: 32 /* TrueCondition */,
74502
+ node: expr,
74503
+ antecedent
74504
+ };
74505
+ const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
74506
+ if (trueType2 === initType && !forceFullCheck)
74507
+ return void 0;
74508
+ const falseCondition = {
74509
+ ...trueCondition,
74510
+ flags: 64 /* FalseCondition */
74511
+ };
74512
+ const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
74513
+ const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
74514
+ if (isTypeIdenticalTo(candidateFalse, falseType2)) {
74515
+ return trueType2;
74516
+ }
74517
+ }
74518
+ }
74455
74519
  function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
74456
74520
  addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
74457
74521
  return;
@@ -76054,7 +76118,7 @@ function createTypeChecker(host) {
76054
76118
  }
76055
76119
  }
76056
76120
  }
76057
- return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
76121
+ return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
76058
76122
  }
76059
76123
  }
76060
76124
  }
package/lib/tsserver.js CHANGED
@@ -6733,7 +6733,6 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
6733
6733
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
6734
6734
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
6735
6735
  ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
6736
- ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
6737
6736
  ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
6738
6737
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
6739
6738
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -53520,7 +53519,7 @@ function createTypeChecker(host) {
53520
53519
  }
53521
53520
  const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
53522
53521
  if (some(abstractSignatures)) {
53523
- const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
53522
+ const types = map(abstractSignatures, getOrCreateTypeFromSignature);
53524
53523
  const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
53525
53524
  // the logic in `createTypeNodesFromResolvedType`.
53526
53525
  (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -60762,7 +60761,15 @@ function createTypeChecker(host) {
60762
60761
  jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
60763
60762
  }
60764
60763
  }
60765
- signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
60764
+ if (type || jsdocPredicate) {
60765
+ signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
60766
+ } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
60767
+ const { declaration } = signature;
60768
+ signature.resolvedTypePredicate = noTypePredicate;
60769
+ signature.resolvedTypePredicate = getTypePredicateFromBody(declaration, signature) || noTypePredicate;
60770
+ } else {
60771
+ signature.resolvedTypePredicate = noTypePredicate;
60772
+ }
60766
60773
  }
60767
60774
  Debug.assert(!!signature.resolvedTypePredicate);
60768
60775
  }
@@ -60914,12 +60921,6 @@ function createTypeChecker(host) {
60914
60921
  isInJSFile(signature.declaration)
60915
60922
  );
60916
60923
  }
60917
- function getImplementationSignature(signature) {
60918
- return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
60919
- }
60920
- function createImplementationSignature(signature) {
60921
- return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
60922
- }
60923
60924
  function getBaseSignature(signature) {
60924
60925
  const typeParameters = signature.typeParameters;
60925
60926
  if (typeParameters) {
@@ -60942,22 +60943,12 @@ function createTypeChecker(host) {
60942
60943
  }
60943
60944
  return signature;
60944
60945
  }
60945
- function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
60946
+ function getOrCreateTypeFromSignature(signature) {
60946
60947
  var _a;
60947
60948
  if (!signature.isolatedSignatureType) {
60948
60949
  const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
60949
60950
  const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
60950
- const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
60951
- if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
60952
- type.symbol.declarations = [signature.declaration];
60953
- type.symbol.valueDeclaration = signature.declaration;
60954
- }
60955
- outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
60956
- signature.declaration,
60957
- /*includeThisTypes*/
60958
- true
60959
- ));
60960
- type.outerTypeParameters = outerTypeParameters;
60951
+ const type = createObjectType(16 /* Anonymous */);
60961
60952
  type.members = emptySymbols;
60962
60953
  type.properties = emptyArray;
60963
60954
  type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -64350,7 +64341,7 @@ function createTypeChecker(host) {
64350
64341
  const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
64351
64342
  const links = getNodeLinks(declaration);
64352
64343
  const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
64353
- let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
64344
+ let typeParameters = links.outerTypeParameters;
64354
64345
  if (!typeParameters) {
64355
64346
  let outerTypeParameters = getOuterTypeParameters(
64356
64347
  declaration,
@@ -64531,9 +64522,6 @@ function createTypeChecker(host) {
64531
64522
  if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
64532
64523
  result.node = type.node;
64533
64524
  }
64534
- if (type.objectFlags & 134217728 /* SingleSignatureType */) {
64535
- result.outerTypeParameters = type.outerTypeParameters;
64536
- }
64537
64525
  result.target = type;
64538
64526
  result.mapper = mapper;
64539
64527
  result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -69154,7 +69142,7 @@ function createTypeChecker(host) {
69154
69142
  if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
69155
69143
  return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
69156
69144
  }
69157
- const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
69145
+ const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
69158
69146
  if (type.flags & 3899393 /* ObjectFlagsType */) {
69159
69147
  type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
69160
69148
  }
@@ -69436,9 +69424,6 @@ function createTypeChecker(host) {
69436
69424
  pos = p;
69437
69425
  }
69438
69426
  }
69439
- function isTupleOfSelf(typeParameter, type) {
69440
- return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
69441
- }
69442
69427
  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
69443
69428
  let bivariant = false;
69444
69429
  let propagationType;
@@ -69524,9 +69509,6 @@ function createTypeChecker(host) {
69524
69509
  inference.priority = priority;
69525
69510
  }
69526
69511
  if (priority === inference.priority) {
69527
- if (isTupleOfSelf(inference.typeParameter, candidate)) {
69528
- return;
69529
- }
69530
69512
  if (contravariant && !bivariant) {
69531
69513
  if (!contains(inference.contraCandidates, candidate)) {
69532
69514
  inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -70093,7 +70075,9 @@ function createTypeChecker(host) {
70093
70075
  inferredType = silentNeverType;
70094
70076
  } else {
70095
70077
  const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
70096
- inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
70078
+ if (defaultType) {
70079
+ inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
70080
+ }
70097
70081
  }
70098
70082
  } else {
70099
70083
  inferredType = getTypeFromInference(inference);
@@ -76481,7 +76465,7 @@ function createTypeChecker(host) {
76481
76465
  void 0,
76482
76466
  checkMode
76483
76467
  );
76484
- const checkArgType = instantiateType(checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType, signature.mapper);
76468
+ const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
76485
76469
  const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
76486
76470
  if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
76487
76471
  Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -77025,16 +77009,13 @@ function createTypeChecker(host) {
77025
77009
  return candidate;
77026
77010
  }
77027
77011
  for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
77028
- let candidate = candidates2[candidateIndex];
77012
+ const candidate = candidates2[candidateIndex];
77029
77013
  if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
77030
77014
  continue;
77031
77015
  }
77032
77016
  let checkCandidate;
77033
77017
  let inferenceContext;
77034
77018
  if (candidate.typeParameters) {
77035
- if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
77036
- candidate = getImplementationSignature(candidate);
77037
- }
77038
77019
  let typeArgumentTypes;
77039
77020
  if (some(typeArguments)) {
77040
77021
  typeArgumentTypes = checkTypeArguments(
@@ -77054,7 +77035,7 @@ function createTypeChecker(host) {
77054
77035
  /*flags*/
77055
77036
  isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
77056
77037
  );
77057
- typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
77038
+ typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
77058
77039
  argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
77059
77040
  }
77060
77041
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -77082,7 +77063,7 @@ function createTypeChecker(host) {
77082
77063
  if (argCheckMode) {
77083
77064
  argCheckMode = 0 /* Normal */;
77084
77065
  if (inferenceContext) {
77085
- const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
77066
+ const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
77086
77067
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
77087
77068
  if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
77088
77069
  candidateForArgumentArityError = checkCandidate;
@@ -79197,6 +79178,89 @@ function createTypeChecker(host) {
79197
79178
  return false;
79198
79179
  }
79199
79180
  }
79181
+ function getTypePredicateFromBody(func, _sig) {
79182
+ const functionFlags = getFunctionFlags(func);
79183
+ if (functionFlags !== 0 /* Normal */)
79184
+ return void 0;
79185
+ let singleReturn;
79186
+ if (func.body && func.body.kind !== 241 /* Block */) {
79187
+ singleReturn = func.body;
79188
+ } else {
79189
+ if (functionHasImplicitReturn(func))
79190
+ return void 0;
79191
+ const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
79192
+ if (singleReturn || !returnStatement.expression)
79193
+ return true;
79194
+ singleReturn = returnStatement.expression;
79195
+ });
79196
+ if (bailedEarly || !singleReturn)
79197
+ return void 0;
79198
+ }
79199
+ const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
79200
+ if (predicate) {
79201
+ const [i, type] = predicate;
79202
+ const param = func.parameters[i];
79203
+ if (isIdentifier(param.name)) {
79204
+ return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
79205
+ }
79206
+ }
79207
+ return void 0;
79208
+ function checkIfExpressionRefinesAnyParameter(expr) {
79209
+ expr = skipParentheses(
79210
+ expr,
79211
+ /*excludeJSDocTypeAssertions*/
79212
+ true
79213
+ );
79214
+ const type = checkExpressionCached(expr, 64 /* TypeOnly */);
79215
+ if (type !== booleanType || !func.body)
79216
+ return void 0;
79217
+ return forEach(func.parameters, (param, i) => {
79218
+ const initType = getSymbolLinks(param.symbol).type;
79219
+ if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
79220
+ return;
79221
+ }
79222
+ const trueType2 = checkIfExpressionRefinesParameter(
79223
+ expr,
79224
+ param,
79225
+ initType,
79226
+ /*forceFullCheck*/
79227
+ false
79228
+ );
79229
+ if (trueType2) {
79230
+ const trueSubtype = checkIfExpressionRefinesParameter(
79231
+ expr,
79232
+ param,
79233
+ trueType2,
79234
+ /*forceFullCheck*/
79235
+ true
79236
+ );
79237
+ if (trueSubtype) {
79238
+ return [i, trueType2];
79239
+ }
79240
+ }
79241
+ });
79242
+ }
79243
+ function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
79244
+ const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
79245
+ const trueCondition = {
79246
+ flags: 32 /* TrueCondition */,
79247
+ node: expr,
79248
+ antecedent
79249
+ };
79250
+ const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
79251
+ if (trueType2 === initType && !forceFullCheck)
79252
+ return void 0;
79253
+ const falseCondition = {
79254
+ ...trueCondition,
79255
+ flags: 64 /* FalseCondition */
79256
+ };
79257
+ const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
79258
+ const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
79259
+ if (isTypeIdenticalTo(candidateFalse, falseType2)) {
79260
+ return trueType2;
79261
+ }
79262
+ }
79263
+ }
79200
79264
  function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
79201
79265
  addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
79202
79266
  return;
@@ -80799,7 +80863,7 @@ function createTypeChecker(host) {
80799
80863
  }
80800
80864
  }
80801
80865
  }
80802
- return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
80866
+ return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
80803
80867
  }
80804
80868
  }
80805
80869
  }
@@ -183991,7 +184055,7 @@ Dynamic files must always be opened with service's current directory or service
183991
184055
  return;
183992
184056
  }
183993
184057
  this.logger.info(`Enabling plugin ${pluginConfigEntry.name} from candidate paths: ${searchPaths.join(",")}`);
183994
- if (!pluginConfigEntry.name || parsePackageName(pluginConfigEntry.name).rest) {
184058
+ if (!pluginConfigEntry.name || isExternalModuleNameRelative(pluginConfigEntry.name) || /[\\/]\.\.?($|[\\/])/.test(pluginConfigEntry.name)) {
183995
184059
  this.logger.info(`Skipped loading plugin ${pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)} because only package name is allowed plugin name`);
183996
184060
  return;
183997
184061
  }
@@ -7242,7 +7242,6 @@ declare namespace ts {
7242
7242
  ContainsSpread = 2097152,
7243
7243
  ObjectRestType = 4194304,
7244
7244
  InstantiationExpressionType = 8388608,
7245
- SingleSignatureType = 134217728,
7246
7245
  }
7247
7246
  interface ObjectType extends Type {
7248
7247
  objectFlags: ObjectFlags;
package/lib/typescript.js CHANGED
@@ -4485,7 +4485,6 @@ ${lanes.join("\n")}
4485
4485
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
4486
4486
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
4487
4487
  ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
4488
- ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
4489
4488
  ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
4490
4489
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
4491
4490
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -51274,7 +51273,7 @@ ${lanes.join("\n")}
51274
51273
  }
51275
51274
  const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
51276
51275
  if (some(abstractSignatures)) {
51277
- const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
51276
+ const types = map(abstractSignatures, getOrCreateTypeFromSignature);
51278
51277
  const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
51279
51278
  // the logic in `createTypeNodesFromResolvedType`.
51280
51279
  (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -58516,7 +58515,15 @@ ${lanes.join("\n")}
58516
58515
  jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
58517
58516
  }
58518
58517
  }
58519
- signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
58518
+ if (type || jsdocPredicate) {
58519
+ signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
58520
+ } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
58521
+ const { declaration } = signature;
58522
+ signature.resolvedTypePredicate = noTypePredicate;
58523
+ signature.resolvedTypePredicate = getTypePredicateFromBody(declaration, signature) || noTypePredicate;
58524
+ } else {
58525
+ signature.resolvedTypePredicate = noTypePredicate;
58526
+ }
58520
58527
  }
58521
58528
  Debug.assert(!!signature.resolvedTypePredicate);
58522
58529
  }
@@ -58668,12 +58675,6 @@ ${lanes.join("\n")}
58668
58675
  isInJSFile(signature.declaration)
58669
58676
  );
58670
58677
  }
58671
- function getImplementationSignature(signature) {
58672
- return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
58673
- }
58674
- function createImplementationSignature(signature) {
58675
- return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
58676
- }
58677
58678
  function getBaseSignature(signature) {
58678
58679
  const typeParameters = signature.typeParameters;
58679
58680
  if (typeParameters) {
@@ -58696,22 +58697,12 @@ ${lanes.join("\n")}
58696
58697
  }
58697
58698
  return signature;
58698
58699
  }
58699
- function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
58700
+ function getOrCreateTypeFromSignature(signature) {
58700
58701
  var _a;
58701
58702
  if (!signature.isolatedSignatureType) {
58702
58703
  const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
58703
58704
  const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
58704
- const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
58705
- if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
58706
- type.symbol.declarations = [signature.declaration];
58707
- type.symbol.valueDeclaration = signature.declaration;
58708
- }
58709
- outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
58710
- signature.declaration,
58711
- /*includeThisTypes*/
58712
- true
58713
- ));
58714
- type.outerTypeParameters = outerTypeParameters;
58705
+ const type = createObjectType(16 /* Anonymous */);
58715
58706
  type.members = emptySymbols;
58716
58707
  type.properties = emptyArray;
58717
58708
  type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -62104,7 +62095,7 @@ ${lanes.join("\n")}
62104
62095
  const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
62105
62096
  const links = getNodeLinks(declaration);
62106
62097
  const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
62107
- let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
62098
+ let typeParameters = links.outerTypeParameters;
62108
62099
  if (!typeParameters) {
62109
62100
  let outerTypeParameters = getOuterTypeParameters(
62110
62101
  declaration,
@@ -62285,9 +62276,6 @@ ${lanes.join("\n")}
62285
62276
  if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
62286
62277
  result.node = type.node;
62287
62278
  }
62288
- if (type.objectFlags & 134217728 /* SingleSignatureType */) {
62289
- result.outerTypeParameters = type.outerTypeParameters;
62290
- }
62291
62279
  result.target = type;
62292
62280
  result.mapper = mapper;
62293
62281
  result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -66908,7 +66896,7 @@ ${lanes.join("\n")}
66908
66896
  if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
66909
66897
  return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
66910
66898
  }
66911
- const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
66899
+ const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
66912
66900
  if (type.flags & 3899393 /* ObjectFlagsType */) {
66913
66901
  type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
66914
66902
  }
@@ -67190,9 +67178,6 @@ ${lanes.join("\n")}
67190
67178
  pos = p;
67191
67179
  }
67192
67180
  }
67193
- function isTupleOfSelf(typeParameter, type) {
67194
- return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
67195
- }
67196
67181
  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
67197
67182
  let bivariant = false;
67198
67183
  let propagationType;
@@ -67278,9 +67263,6 @@ ${lanes.join("\n")}
67278
67263
  inference.priority = priority;
67279
67264
  }
67280
67265
  if (priority === inference.priority) {
67281
- if (isTupleOfSelf(inference.typeParameter, candidate)) {
67282
- return;
67283
- }
67284
67266
  if (contravariant && !bivariant) {
67285
67267
  if (!contains(inference.contraCandidates, candidate)) {
67286
67268
  inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -67847,7 +67829,9 @@ ${lanes.join("\n")}
67847
67829
  inferredType = silentNeverType;
67848
67830
  } else {
67849
67831
  const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
67850
- inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
67832
+ if (defaultType) {
67833
+ inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
67834
+ }
67851
67835
  }
67852
67836
  } else {
67853
67837
  inferredType = getTypeFromInference(inference);
@@ -74235,7 +74219,7 @@ ${lanes.join("\n")}
74235
74219
  void 0,
74236
74220
  checkMode
74237
74221
  );
74238
- const checkArgType = instantiateType(checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType, signature.mapper);
74222
+ const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
74239
74223
  const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
74240
74224
  if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
74241
74225
  Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -74779,16 +74763,13 @@ ${lanes.join("\n")}
74779
74763
  return candidate;
74780
74764
  }
74781
74765
  for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
74782
- let candidate = candidates2[candidateIndex];
74766
+ const candidate = candidates2[candidateIndex];
74783
74767
  if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
74784
74768
  continue;
74785
74769
  }
74786
74770
  let checkCandidate;
74787
74771
  let inferenceContext;
74788
74772
  if (candidate.typeParameters) {
74789
- if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
74790
- candidate = getImplementationSignature(candidate);
74791
- }
74792
74773
  let typeArgumentTypes;
74793
74774
  if (some(typeArguments)) {
74794
74775
  typeArgumentTypes = checkTypeArguments(
@@ -74808,7 +74789,7 @@ ${lanes.join("\n")}
74808
74789
  /*flags*/
74809
74790
  isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
74810
74791
  );
74811
- typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
74792
+ typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
74812
74793
  argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
74813
74794
  }
74814
74795
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -74836,7 +74817,7 @@ ${lanes.join("\n")}
74836
74817
  if (argCheckMode) {
74837
74818
  argCheckMode = 0 /* Normal */;
74838
74819
  if (inferenceContext) {
74839
- const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
74820
+ const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
74840
74821
  checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
74841
74822
  if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
74842
74823
  candidateForArgumentArityError = checkCandidate;
@@ -76951,6 +76932,89 @@ ${lanes.join("\n")}
76951
76932
  return false;
76952
76933
  }
76953
76934
  }
76935
+ function getTypePredicateFromBody(func, _sig) {
76936
+ const functionFlags = getFunctionFlags(func);
76937
+ if (functionFlags !== 0 /* Normal */)
76938
+ return void 0;
76939
+ let singleReturn;
76940
+ if (func.body && func.body.kind !== 241 /* Block */) {
76941
+ singleReturn = func.body;
76942
+ } else {
76943
+ if (functionHasImplicitReturn(func))
76944
+ return void 0;
76945
+ const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
76946
+ if (singleReturn || !returnStatement.expression)
76947
+ return true;
76948
+ singleReturn = returnStatement.expression;
76949
+ });
76950
+ if (bailedEarly || !singleReturn)
76951
+ return void 0;
76952
+ }
76953
+ const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
76954
+ if (predicate) {
76955
+ const [i, type] = predicate;
76956
+ const param = func.parameters[i];
76957
+ if (isIdentifier(param.name)) {
76958
+ return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
76959
+ }
76960
+ }
76961
+ return void 0;
76962
+ function checkIfExpressionRefinesAnyParameter(expr) {
76963
+ expr = skipParentheses(
76964
+ expr,
76965
+ /*excludeJSDocTypeAssertions*/
76966
+ true
76967
+ );
76968
+ const type = checkExpressionCached(expr, 64 /* TypeOnly */);
76969
+ if (type !== booleanType || !func.body)
76970
+ return void 0;
76971
+ return forEach(func.parameters, (param, i) => {
76972
+ const initType = getSymbolLinks(param.symbol).type;
76973
+ if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
76974
+ return;
76975
+ }
76976
+ const trueType2 = checkIfExpressionRefinesParameter(
76977
+ expr,
76978
+ param,
76979
+ initType,
76980
+ /*forceFullCheck*/
76981
+ false
76982
+ );
76983
+ if (trueType2) {
76984
+ const trueSubtype = checkIfExpressionRefinesParameter(
76985
+ expr,
76986
+ param,
76987
+ trueType2,
76988
+ /*forceFullCheck*/
76989
+ true
76990
+ );
76991
+ if (trueSubtype) {
76992
+ return [i, trueType2];
76993
+ }
76994
+ }
76995
+ });
76996
+ }
76997
+ function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
76998
+ const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
76999
+ const trueCondition = {
77000
+ flags: 32 /* TrueCondition */,
77001
+ node: expr,
77002
+ antecedent
77003
+ };
77004
+ const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
77005
+ if (trueType2 === initType && !forceFullCheck)
77006
+ return void 0;
77007
+ const falseCondition = {
77008
+ ...trueCondition,
77009
+ flags: 64 /* FalseCondition */
77010
+ };
77011
+ const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
77012
+ const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
77013
+ if (isTypeIdenticalTo(candidateFalse, falseType2)) {
77014
+ return trueType2;
77015
+ }
77016
+ }
77017
+ }
76954
77018
  function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
76955
77019
  addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
76956
77020
  return;
@@ -78553,7 +78617,7 @@ ${lanes.join("\n")}
78553
78617
  }
78554
78618
  }
78555
78619
  }
78556
- return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
78620
+ return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
78557
78621
  }
78558
78622
  }
78559
78623
  }
@@ -181310,7 +181374,7 @@ Dynamic files must always be opened with service's current directory or service
181310
181374
  return;
181311
181375
  }
181312
181376
  this.logger.info(`Enabling plugin ${pluginConfigEntry.name} from candidate paths: ${searchPaths.join(",")}`);
181313
- if (!pluginConfigEntry.name || parsePackageName(pluginConfigEntry.name).rest) {
181377
+ if (!pluginConfigEntry.name || isExternalModuleNameRelative(pluginConfigEntry.name) || /[\\/]\.\.?($|[\\/])/.test(pluginConfigEntry.name)) {
181314
181378
  this.logger.info(`Skipped loading plugin ${pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)} because only package name is allowed plugin name`);
181315
181379
  return;
181316
181380
  }
@@ -3142,7 +3142,6 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
3142
3142
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
3143
3143
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
3144
3144
  ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
3145
- ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
3146
3145
  ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
3147
3146
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
3148
3147
  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "@typescript-deploys/pr-build",
3
3
  "author": "Microsoft Corp.",
4
4
  "homepage": "https://www.typescriptlang.org/",
5
- "version": "5.5.0-pr-57403-12",
5
+ "version": "5.5.0-pr-57465-17",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [
@@ -114,5 +114,5 @@
114
114
  "node": "20.1.0",
115
115
  "npm": "8.19.4"
116
116
  },
117
- "gitHead": "70338f99ff0955fde9fe29b360c4bd685ac8d868"
117
+ "gitHead": "ef7996632fbbd9382ba181bef671a581e4bea069"
118
118
  }