@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 +105 -41
- package/lib/tsserver.js +106 -42
- package/lib/typescript.d.ts +0 -1
- package/lib/typescript.js +106 -42
- package/lib/typingsInstaller.js +0 -1
- package/package.json +2 -2
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,
|
|
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
|
-
|
|
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
|
|
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 */
|
|
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 =
|
|
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 &
|
|
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
|
-
|
|
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 =
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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)
|
|
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,
|
|
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
|
-
|
|
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
|
|
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 */
|
|
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 =
|
|
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 &
|
|
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
|
-
|
|
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 =
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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)
|
|
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 ||
|
|
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
|
}
|
package/lib/typescript.d.ts
CHANGED
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,
|
|
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
|
-
|
|
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
|
|
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 */
|
|
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 =
|
|
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 &
|
|
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
|
-
|
|
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 =
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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)
|
|
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 ||
|
|
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
|
}
|
package/lib/typingsInstaller.js
CHANGED
|
@@ -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-
|
|
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": "
|
|
117
|
+
"gitHead": "ef7996632fbbd9382ba181bef671a581e4bea069"
|
|
118
118
|
}
|