corsa-oxlint 1.14.0 → 1.14.2

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 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 args = Array.isArray(rawArgs) ? rawArgs.filter(isNode) : [];
278
- const callSignature = checker.getCallSignatureFacts(calleeType, 0, args.map((arg) => typeTextsAtCallArgument(context, arg, checker)), explicitTypeArgumentTexts(context, node)).signature ?? checker.getSignaturesOfType(calleeType, 0)[0];
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
- sessionForContext(context).session.rememberTypeLookupFromType(returnType, calleeType);
283
- return returnType;
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 typeTextsAtCallArgument(context, node, checker) {
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 [...values];
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
- if (index !== void 0 && arrayLikeTypeText(text)) return typeArguments[0];
355
- if (computedPropertyName(property) !== void 0 && recordLikeTypeText(text)) return typeArguments[1];
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");