corsa-oxlint 1.13.2 → 1.14.1
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/dist/checker.js +87 -9
- package/dist/checker.js.map +1 -1
- package/dist/parser_services.js +6 -0
- package/dist/parser_services.js.map +1 -1
- package/dist/registry.d.ts +1 -1
- package/dist/session.d.ts +46 -2
- package/dist/session.js +89 -3
- package/dist/session.js.map +1 -1
- package/dist/types.d.ts +20 -2
- package/dist/types.js.map +1 -1
- package/package.json +2 -2
package/dist/checker.js
CHANGED
|
@@ -22,6 +22,12 @@ function createProgram(context) {
|
|
|
22
22
|
text: context.sourceCode.text
|
|
23
23
|
};
|
|
24
24
|
},
|
|
25
|
+
getContentMapping(fileName = context.filename) {
|
|
26
|
+
return sessionForContext(context).session.getContentMapping(fileName);
|
|
27
|
+
},
|
|
28
|
+
getContentMappers() {
|
|
29
|
+
return sessionForContext(context).session.getContentMappers();
|
|
30
|
+
},
|
|
25
31
|
getTypeChecker() {
|
|
26
32
|
return createTypeChecker(context);
|
|
27
33
|
}
|
|
@@ -40,6 +46,10 @@ function createTypeChecker(context) {
|
|
|
40
46
|
const resolved = typeOfAwaitExpression(context, node, this);
|
|
41
47
|
if (resolved) return resolved;
|
|
42
48
|
}
|
|
49
|
+
if (kind === "TSNonNullExpression") {
|
|
50
|
+
const resolved = typeOfNonNullExpression(context, node, this);
|
|
51
|
+
if (resolved) return resolved;
|
|
52
|
+
}
|
|
43
53
|
if (kind === "MemberExpression") {
|
|
44
54
|
const resolved = typeOfComputedMemberExpression(context, node, this);
|
|
45
55
|
if (resolved) return resolved;
|
|
@@ -110,6 +120,9 @@ function createTypeChecker(context) {
|
|
|
110
120
|
getPropertiesOfType(type) {
|
|
111
121
|
return sessionForContext(context).session.getPropertiesOfType(type);
|
|
112
122
|
},
|
|
123
|
+
getIndexInfosOfType(type) {
|
|
124
|
+
return sessionForContext(context).session.getIndexInfosOfType(type);
|
|
125
|
+
},
|
|
113
126
|
getSignaturesOfType(type, kind) {
|
|
114
127
|
return sessionForContext(context).session.getSignaturesOfType(type, kind);
|
|
115
128
|
},
|
|
@@ -122,6 +135,9 @@ function createTypeChecker(context) {
|
|
|
122
135
|
getTypePredicateOfSignature(signature) {
|
|
123
136
|
return sessionForContext(context).session.getTypePredicateOfSignature(signature);
|
|
124
137
|
},
|
|
138
|
+
getNonNullableType(type) {
|
|
139
|
+
return sessionForContext(context).session.getNonNullableType(type);
|
|
140
|
+
},
|
|
125
141
|
getBaseTypes(type) {
|
|
126
142
|
if (isSuperclassConstructorLookup(context, type)) {
|
|
127
143
|
const constructorBases = constructorBaseTypesFromType(context, type, this);
|
|
@@ -202,6 +218,7 @@ function primeImplementedTypesCacheFromNode(context, node, type, checker) {
|
|
|
202
218
|
session.cacheOwnImplementedTypes(type.id, checker.getImplementedTypes(node));
|
|
203
219
|
}
|
|
204
220
|
const typeFlags = {
|
|
221
|
+
typeParameter: 1 << 19,
|
|
205
222
|
union: 1 << 27,
|
|
206
223
|
intersection: 1 << 28
|
|
207
224
|
};
|
|
@@ -274,27 +291,47 @@ function typeOfCallExpression(context, node, checker) {
|
|
|
274
291
|
const calleeType = checker.getTypeAtLocation(callee);
|
|
275
292
|
if (!calleeType) return;
|
|
276
293
|
const rawArgs = node.arguments;
|
|
277
|
-
const
|
|
278
|
-
const
|
|
294
|
+
const argumentTypes = (Array.isArray(rawArgs) ? rawArgs.filter(isNode) : []).map((arg) => typeInfoAtCallArgument(context, arg, checker));
|
|
295
|
+
const signatureFacts = checker.getCallSignatureFacts(calleeType, 0, argumentTypes.map((arg) => arg.texts), explicitTypeArgumentTexts(context, node));
|
|
296
|
+
const callSignature = signatureFacts.signature ?? checker.getSignaturesOfType(calleeType, 0)[0];
|
|
279
297
|
if (!callSignature) return;
|
|
280
298
|
const returnType = checker.getReturnTypeOfSignature(callSignature);
|
|
281
299
|
if (!returnType) return;
|
|
282
|
-
|
|
283
|
-
|
|
300
|
+
const inferredReturnType = typeOfInferredGenericReturn(returnType, callSignature, signatureFacts, argumentTypes, checker) ?? returnType;
|
|
301
|
+
sessionForContext(context).session.rememberTypeLookupFromType(inferredReturnType, returnType);
|
|
302
|
+
sessionForContext(context).session.rememberTypeLookupFromType(inferredReturnType, calleeType);
|
|
303
|
+
return inferredReturnType;
|
|
284
304
|
}
|
|
285
|
-
function
|
|
305
|
+
function typeInfoAtCallArgument(context, node, checker) {
|
|
286
306
|
const values = /* @__PURE__ */ new Set();
|
|
287
307
|
const nodeType = checker.getTypeAtLocation(node);
|
|
308
|
+
collectTexts(nodeType);
|
|
288
309
|
collectTexts(nodeType ? checker.getBaseTypeOfLiteralType(nodeType) ?? nodeType : void 0);
|
|
289
310
|
const symbol = checker.getSymbolAtLocation(node);
|
|
290
311
|
const symbolType = symbol ? checker.getTypeOfSymbol(symbol) ?? checker.getDeclaredTypeOfSymbol(symbol) : void 0;
|
|
312
|
+
collectTexts(symbolType);
|
|
291
313
|
collectTexts(symbolType ? checker.getBaseTypeOfLiteralType(symbolType) ?? symbolType : void 0);
|
|
292
|
-
return
|
|
314
|
+
return {
|
|
315
|
+
type: nodeType ?? symbolType,
|
|
316
|
+
texts: [...values]
|
|
317
|
+
};
|
|
293
318
|
function collectTexts(type) {
|
|
294
319
|
if (!type) return;
|
|
295
320
|
for (const text of [...type.texts ?? [], safeTypeToString(checker, type) ?? ""]) if (text) values.add(text);
|
|
296
321
|
}
|
|
297
322
|
}
|
|
323
|
+
function typeOfInferredGenericReturn(returnType, signature, facts, argumentTypes, checker) {
|
|
324
|
+
if (signature.typeParameters.length === 0) return;
|
|
325
|
+
if ((returnType.flags & typeFlags.typeParameter) === 0) return;
|
|
326
|
+
const returnTexts = typeTexts(returnType, checker).map(normalizeTypeText);
|
|
327
|
+
if (returnTexts.length === 0) return;
|
|
328
|
+
for (const [index, argument] of argumentTypes.entries()) {
|
|
329
|
+
if (!argument.type) continue;
|
|
330
|
+
const expectedTexts = facts.expectedArgumentTypeTexts?.[index] ?? signature.parameterTypeTexts?.[index];
|
|
331
|
+
if (!expectedTexts) continue;
|
|
332
|
+
if (expectedTexts.map(normalizeTypeText).some((text) => returnTexts.includes(text))) return argument.type;
|
|
333
|
+
}
|
|
334
|
+
}
|
|
298
335
|
function explicitTypeArgumentTexts(context, node) {
|
|
299
336
|
const explicitNodes = typeArgumentNodes(node);
|
|
300
337
|
if (explicitNodes.length > 0) return explicitNodes.map((typeArgument) => context.sourceCode.getText(typeArgument)).filter((text) => text.length > 0);
|
|
@@ -329,6 +366,15 @@ function typeOfAwaitExpression(context, node, checker) {
|
|
|
329
366
|
sessionForContext(context).session.rememberTypeLookupFromType(awaited, argumentType);
|
|
330
367
|
return awaited;
|
|
331
368
|
}
|
|
369
|
+
function typeOfNonNullExpression(context, node, checker) {
|
|
370
|
+
const expression = childNode(node, "expression");
|
|
371
|
+
if (!expression) return;
|
|
372
|
+
const expressionType = checker.getTypeAtLocation(expression);
|
|
373
|
+
if (!expressionType) return;
|
|
374
|
+
const nonNullable = checker.getNonNullableType(expressionType) ?? expressionType;
|
|
375
|
+
sessionForContext(context).session.rememberTypeLookupFromType(nonNullable, expressionType);
|
|
376
|
+
return nonNullable;
|
|
377
|
+
}
|
|
332
378
|
function typeOfComputedMemberExpression(context, node, checker) {
|
|
333
379
|
if (node.computed !== true) return;
|
|
334
380
|
const object = childNode(node, "object");
|
|
@@ -337,7 +383,7 @@ function typeOfComputedMemberExpression(context, node, checker) {
|
|
|
337
383
|
const objectType = checker.getTypeAtLocation(object);
|
|
338
384
|
if (!objectType) return;
|
|
339
385
|
const propertyName = computedPropertyName(property);
|
|
340
|
-
const indexedType = (propertyName ? typeOfNamedProperty(objectType, propertyName, checker) : void 0) ?? typeOfIndexedMember(objectType, property, checker);
|
|
386
|
+
const indexedType = (propertyName ? typeOfNamedProperty(objectType, propertyName, checker) : void 0) ?? typeOfIndexSignatureMember(objectType, property, checker) ?? typeOfIndexedMember(objectType, property, checker);
|
|
341
387
|
if (indexedType) sessionForContext(context).session.rememberTypeLookupFromType(indexedType, objectType);
|
|
342
388
|
return indexedType;
|
|
343
389
|
}
|
|
@@ -345,14 +391,46 @@ function typeOfNamedProperty(objectType, propertyName, checker) {
|
|
|
345
391
|
const symbol = checker.getPropertiesOfType(objectType).find((property) => property.name === propertyName);
|
|
346
392
|
return symbol ? checker.getTypeOfSymbol(symbol) ?? checker.getDeclaredTypeOfSymbol(symbol) : void 0;
|
|
347
393
|
}
|
|
394
|
+
function typeOfIndexSignatureMember(objectType, property, checker) {
|
|
395
|
+
const propertyTypes = indexedPropertyTypes(property, checker);
|
|
396
|
+
for (const info of checker.getIndexInfosOfType(objectType)) if (indexKeyMatches(property, propertyTypes, info.keyType, checker)) return info.valueType;
|
|
397
|
+
}
|
|
348
398
|
function typeOfIndexedMember(objectType, property, checker) {
|
|
349
399
|
const typeArguments = checker.getTypeArguments(objectType);
|
|
350
400
|
if (typeArguments.length === 0) return;
|
|
351
401
|
const text = safeTypeToString(checker, objectType) ?? objectType.texts?.[0] ?? "";
|
|
352
402
|
const index = numericLiteralValue(property);
|
|
353
403
|
if (index !== void 0 && tupleLikeTypeText(text)) return typeArguments[index];
|
|
354
|
-
|
|
355
|
-
if (
|
|
404
|
+
const propertyTypes = indexedPropertyTypes(property, checker);
|
|
405
|
+
if (propertyCanIndexArray(propertyTypes, checker) && tupleLikeTypeText(text)) return syntheticCompoundType("union", typeArguments, checker);
|
|
406
|
+
if ((index !== void 0 || propertyCanIndexArray(propertyTypes, checker)) && !tupleLikeTypeText(text) && arrayLikeTypeText(text)) return typeArguments[0];
|
|
407
|
+
if (recordLikeTypeText(text) && (computedPropertyName(property) !== void 0 || indexKeyMatches(property, propertyTypes, typeArguments[0], checker))) return typeArguments[1];
|
|
408
|
+
}
|
|
409
|
+
function indexedPropertyTypes(property, checker) {
|
|
410
|
+
const type = checker.getTypeAtLocation(property);
|
|
411
|
+
if (!type) return [];
|
|
412
|
+
const base = checker.getBaseTypeOfLiteralType(type);
|
|
413
|
+
return uniqueTypesById(base ? [type, base] : [type]);
|
|
414
|
+
}
|
|
415
|
+
function propertyCanIndexArray(propertyTypes, checker) {
|
|
416
|
+
return propertyTypes.some((type) => typeTexts(type, checker).some((text) => normalizeTypeText(text) === "number"));
|
|
417
|
+
}
|
|
418
|
+
function indexKeyMatches(property, propertyTypes, keyType, checker) {
|
|
419
|
+
if (propertyTypes.some((propertyType) => checker.isTypeAssignableTo(propertyType, keyType) === true)) return true;
|
|
420
|
+
const keyTexts = typeTexts(keyType, checker).map(normalizeTypeText);
|
|
421
|
+
if (numericLiteralValue(property) !== void 0) return keyTexts.includes("number") || keyTexts.includes("string");
|
|
422
|
+
if (computedPropertyName(property) !== void 0) return keyTexts.includes("string");
|
|
423
|
+
return false;
|
|
424
|
+
}
|
|
425
|
+
function typeTexts(type, checker) {
|
|
426
|
+
const values = /* @__PURE__ */ new Set();
|
|
427
|
+
for (const text of type.texts ?? []) if (text) values.add(text);
|
|
428
|
+
const rendered = safeTypeToString(checker, type);
|
|
429
|
+
if (rendered) values.add(rendered);
|
|
430
|
+
return [...values];
|
|
431
|
+
}
|
|
432
|
+
function normalizeTypeText(text) {
|
|
433
|
+
return text.split(/\s+/).join("");
|
|
356
434
|
}
|
|
357
435
|
function typeOfConditionalExpression(node, checker) {
|
|
358
436
|
const consequent = childNode(node, "consequent");
|