Type information is computed lazily by TS. What this means is that the more type information a rule accesses, the slower that rule is.

Right now all lint rules directly use TS's APIs to ask TS to compute types before operating on those types and asking questions of those types.

I wonder if we can improve the performance here by using the scope analysis information that's already calculated to get some basic types from the AST.
My hypothesis is that there are a lot of questions we're asking that could be answered solely from the AST.

For example:

const x = 1;

const result = x + 1;

For restrict-plus-operands the rule will inspect both sides of the binary expression, ask for types, and then run some predicates over the types to determine if the operation is safe or not.
In this example, however, we shouldn't ever need to ask TS anything - we could solve this entirely using the AST + scope analysis.

For example instead of doing (pseudocode):

BinaryExpression(node) {
  const left = ts.getType(node.left);
  const right = ts.getType(node.right);
  if (isString(left) && isString(right)) { return safe; }
  if (isNumber(left) && isNumber(right)) { return safe; }
  // ...
}

we could potentially circumvent some work by doing something like:

BinaryExpression(node) {
  const left = getTypeFast(node.left);
  const right = getTypeFast(node.right);
  if (isString(left) && isString(right)) { return safe; }
  if (isNumber(left) && isNumber(right)) { return safe; }
}

function getTypeFast(node) {
  const scopeAnalysisType = getScopeAnalysisType(node);
  if (scopeAnalysisType) {
    return scopeAnalysisType;
  }
  return ts.getType(node);
}

function getScopeAnalysisType(node) {
  if (node.type === 'Literal') { return typeof node.value }
  if (node.type === 'Identifier') {
    const variable = scopeAnalysis.get(node.name);
    return getScopeAnalysisType(variable.declaration);
  }
  if (
    node.type === 'VariableDeclaration' &&
    node.kind === 'const'
  ) {
    return getScopeAnalysisType(node.init);
  }
  if (
    node.type === 'Parameter' &&
    node.typeAnnotation
  ) {
    return typeOf(node.typeAnnotation);
  }
  return null;
}

It's a lot more code, for sure, but it would save us from having to dip into the types for a number of cases.

Some of the more complex cases (like looking for promises, where we need to deeply inspect the object properties) could be a lot faster if we can circumvent ever asking for the type because we know it's definitely a number.

It would probably be a bit awkward to use any utilities that are built here, but it could work well in conjunction with #6013 if we had our own type API surface to automate some of the short-circuiting for people.