Both index signatures and Records

Oct 13, 2025 by recoveryshake.com 99 views

Enhancement: [no-misused-promises] Include index signatures in our checks for Promise-void mismatches (checksVoidReturn)

Background

In #8765, we decided to leave a TODO to handle unnamed class/interface members properly—specifically, waiting for V8's checker.isTypeAssignableTo to allow properly checking index signatures against inherited ones. (Relevant discussion)

What we don't yet check

After looking more into it, I've realized no-misused-promises not only doesn't check index signatures against inherited signatures, but also doesn't check index signatures in almost any case.

For example, the following code passes without any no-misused-promises errors being flagged:

interface InvalidInterface {
  [syncKey: string]: () => void;
  [asyncFetcher: `fetch${string}`]: () => Promise<void>; // this should error but doesn't
  asyncMethod(): Promise<void>; // this should error but doesn't
  asyncProperty: () => Promise<void>; // this should error but doesn't
}
interface InvalidSubInterface extends InvalidInterface {
  anotherAsyncMethod(): Promise<void>; // this should error but doesn't
  anotherAsyncProperty: () => Promise<void>; // this should error but doesn't
  [asyncKey: string]: () => Promise<void>; // this should error but doesn't
}
const invalidMethodObject: Record<string, () => void> = {
  asyncMethod() { return Promise.resolve(); }, // this should error but doesn't
}

What we do already check

no-misused-promises does already catch one case of Promise-void mismatches involving index signatures: object properties (as opposed to object methods).

Thanks to checker.getContextualType (which we also use for methods, but for some reason doesn't behave the same for them), checksVoidReturn.properties will flag these:

function useSyncFetcherObj(o: {[syncFetcherKey: string]: () => void}): void {
  o.fetchSomething();
}
useSyncFetcherObj({ fetchSomethingAsync: () => Promise.resolve() });  // Promise-returning function provided to property where a void return was expected.

type SyncFetcherObj = Record<string, () => void>;
const asyncFetcherPropertyObj: SyncFetcherObj = {
  getNumber: () => Promise.resolve(1), // Promise-returning function provided to property where a void return was expected.
};

Where to go from here

The practical impact of this change is unclear—beyond technical completeness, it's not obvious if users would benefit enough to justify it. Implementation is possible, but comes with tradeoffs:

Complexity / maintainability

Checking index signatures is trickier than expected, because the TypeScript compiler API doesn't expose all the relevant functions we'd need. On top of likely needing a new option for whether to check index signatures, we'd need to use checker.isTypeAssignableTo to manually implement functions ourselves like these:

import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';

import * as tsutils from 'ts-api-utils';
import * as ts from 'typescript';

import { getTypeOfPropertyName } from './getTypeOfPropertyName';
import { isStaticMember } from './isStaticMember';
import { returnsVoidAndNotThenable } from './returnTypeUtils';

export interface HeritageIndexInfo {
  heritageType: ts.Type;
  indexInfo: ts.IndexInfo;
}

export function getHeritageIndexInfos({
  checker,
  heritageTypes,
}: {
  checker: ts.TypeChecker;
  heritageTypes: ts.Type[];
}): HeritageIndexInfo[] {
  return heritageTypes.flatMap(heritageType => {
    const indexInfos = checker.getIndexInfosOfType(heritageType);
    return indexInfos.map(indexInfo => ({ heritageType, indexInfo }));
  });
}

export function isApplicableIndexInfoForKeyType({
  checker,
  indexInfo,
  keyType,
}: {
  checker: ts.TypeChecker;
  indexInfo: ts.IndexInfo;
  keyType: ts.Type;
}): boolean {
  const { keyType: targetIndexKeyType } = indexInfo;
  return isApplicableIndexKeyType({
    checker,
    sourceIndexKeyType: keyType,
    targetIndexKeyType,
  });
}

/**
 * Implemented based on `checker.isApplicableIndexType` (not exposed in the public API).
 */
export function isApplicableIndexKeyType({
  checker,
  sourceIndexKeyType,
  targetIndexKeyType,
}: {
  checker: ts.TypeChecker;
  sourceIndexKeyType: ts.Type;
  targetIndexKeyType: ts.Type;
}): boolean {
  if (checker.isTypeAssignableTo(sourceIndexKeyType, targetIndexKeyType)) {
    return true;
  }
  if (
    targetIndexKeyType === checker.getStringType() &&
    checker.isTypeAssignableTo(sourceIndexKeyType, checker.getNumberType())
  ) {
    // A 'string' index signature applies to types assignable to 'string' or 'number'
    return true;
  }
  // TS checks for numeric string types and numeric literal names like this, but this might be more
  // trouble than it's worth for us to implement?
  // if (
  //   targetIndexKeyType === checker.getNumberType() &&
  //   (isNumericStringType(checker, sourceIndexKeyType) ||
  //     isNumericLiteralName(sourceIndexKeyType))
  // ) {
  //   // A 'number' index signature applies to types assignable to 'number', `${number}`, and numeric string literal types
  //   return true;
  // }
  return false;
}

function isNumericStringType(checker: ts.TypeChecker, type: ts.Type): boolean {
  if (!tsutils.isTemplateLiteralType(type)) {
    return false;
  }
  // return type.texts.every(text => tsutils.isTypeFlagSet(checker.getTypeAtLocation(text), ts.TypeFlags.NumberLike)) && type.types.every(t => tsutils.isTypeFlagSet(t, ts.TypeFlags.NumberLike));
  return (
    tsutils.isTypeFlagSet(type, ts.TypeFlags.String) &&
    tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLike)
  );
}

function isNumericLiteralName(type: ts.Type): boolean {
  // TODO: Implement this function
  return (
    tsutils.isStringLiteralType(type) &&
    Number(type.value).toString() === type.value
  );
}

export function isApplicableIndexInfoForNamedMember({
  checker,
  indexInfo,
  member,
  memberName,
  services,
}: {
  checker: ts.TypeChecker;
  indexInfo: ts.IndexInfo;
  member: ts.ClassElement | ts.TypeElement;
  memberName: ts.PropertyName;
  services: ParserServicesWithTypeInformation;
}): boolean {
  if (isStaticIndexInfo(indexInfo) && !isStaticMember({ member, services })) {
    return false;
  }
  const memberNameType = getTypeOfPropertyName(checker, memberName);
  return isApplicableIndexInfoForKeyType({
    checker,
    indexInfo,
    keyType: memberNameType,
  });
}

export function getIndexSignatureDeclarationKeyType({
  checker,
  indexSignatureDeclaration,
}: {
  checker: ts.TypeChecker;
  indexSignatureDeclaration: ts.IndexSignatureDeclaration;
}): ts.Type {
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Index signatures always have exactly one parameter
  const typeNode = indexSignatureDeclaration.parameters[0].type!;
  return checker.getTypeAtLocation(typeNode);
}

export function indexInfoReturnsVoidAndNotThenable(
  checker: ts.TypeChecker,
  indexInfo: ts.IndexInfo,
): boolean {
  const { declaration, type } = indexInfo;
  if (!declaration) {
    return false;
  }
  return returnsVoidAndNotThenable(checker, declaration, type);
}

export function isStaticIndexInfo(indexInfo: ts.IndexInfo): boolean {
  const modifiers = indexInfo.declaration?.modifiers;
  if (modifiers == null) {
    return false;
  }
  return modifiers.some(
    modifier => modifier.kind === ts.SyntaxKind.StaticKeyword,
  );
}

Test case coverage

There are a lot of cases and combinations to cover:

Checking against methods/properties/indexes within a type, and against inherited ones
Both types of inheritance: extends clauses and implements clauses
Node types: Classes and class expressions, interfaces, type literals, objects
Both index signatures and Records (although I think they are treated the same under the hood, so we wouldn't need extra code to handle Records; just more test cases)
Inheriting both sync and async types (e.g. declaring a void-returning index signature within a class that inherits an async method should error)
Handling unions of types (both for index key types and index value types)

Summary / my thoughts

Although the original TODO was written while thinking we just needed to check index signatures within a class/interface against inherited index signatures, it turns out we don't yet catch most Promise-void mismatches involving index signatures, even without considering inheritance.

Given the complexity involved, and the lack of user demand so far, my inclination is to leave things as-is for now, aside from updating the existing TODO comment.

Additional Info

No response
Q&A: Enhancement: [no-misused-promises] Include index signatures in our checks for Promise-void mismatches (checksVoidReturn)

Q: What is the current state of the no-misused-promises rule?

A: The no-misused-promises rule currently does not check index signatures against inherited signatures, and also does not check index signatures in almost any case.

Q: What are the implications of not checking index signatures?

A: Not checking index signatures means that the rule will not catch Promise-void mismatches involving index signatures, which can lead to unexpected behavior and errors.

Q: What are the potential solutions to this issue?

A: One potential solution is to implement a new option for whether to check index signatures, and to use checker.isTypeAssignableTo to manually implement functions to check index signatures.

Q: What are the tradeoffs of implementing this solution?

A: The tradeoffs of implementing this solution include increased complexity and maintainability, as well as the need to write additional test cases to cover the new functionality.

Q: What are the potential benefits of implementing this solution?

A: The potential benefits of implementing this solution include improved accuracy and reliability of the no-misused-promises rule, as well as better protection against unexpected behavior and errors.

Q: What is the current status of the implementation?

A: The implementation is still in the planning stages, and no code has been written yet.

Q: What are the next steps for implementing this solution?

A: The next steps for implementing this solution include writing the necessary code to check index signatures, as well as writing additional test cases to cover the new functionality.

Q: What is the expected timeline for implementing this solution?

A: The expected timeline for implementing this solution is not yet clear, but it is likely to be several weeks or months.

Q: How can I get involved in the implementation of this solution?

A: If you are interested in getting involved in the implementation of this solution, please reach out to the maintainers of the no-misused-promises rule and express your interest.

Q: What are the potential risks of implementing this solution?

A: The potential risks of implementing this solution include introducing new bugs or errors, as well as increasing the complexity and maintainability of the code.

Q: How can I provide feedback on the implementation of this solution?

A: You can provide feedback on the implementation of this solution by commenting on the relevant issues and pull requests, or by reaching out to the maintainers of the no-misused-promises rule directly.

Q: What are the expected outcomes of implementing this solution?

A: The expected outcomes of implementing this solution include improved accuracy and reliability of the no-misused-promises rule, as well as better protection against unexpected behavior and errors.

Q: How will the implementation of this solution be tested?

A: The implementation of this solution will be tested through a combination of unit tests, integration tests, and manual testing.

Q: What are the potential challenges of implementing this solution?

A: The potential challenges of implementing this solution include dealing with complex edge cases, as well as ensuring that the new functionality is properly integrated with the existing codebase.