Jan 31, 2023 · Dec 16, 2022 · Dec 17, 2022 · Dec 18, 2022
diff --git a/.eslintrc.js b/.eslintrc.js
    //

    curly: ['error', 'all'],
    eqeqeq: [
      'error',
      'always',
      {
        null: 'never',
      },
    ],
    'no-mixed-operators': 'error',
    'no-console': 'error',
    'no-process-exit': 'error',
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
        case AST_NODE_TYPES.TSDeclareFunction:
        case AST_NODE_TYPES.FunctionDeclaration: {
          const name = member.id?.name ?? null;
          if (name === null) {
          if (name == null) {
            return null;
          }
          return {

        members.forEach(member => {
          const method = getMemberMethod(member);
          if (method === null) {
          if (method == null) {
            lastMethod = null;
            return;
          }
diff --git a/packages/eslint-plugin/src/rules/ban-types.ts b/packages/eslint-plugin/src/rules/ban-types.ts
 function getCustomMessage(
  bannedType: null | string | { message?: string; fixWith?: string },
 ): string {
  if (bannedType === null) {
  if (bannedType == null) {
    return '';
  }

diff --git a/packages/eslint-plugin/src/rules/comma-spacing.ts b/packages/eslint-plugin/src/rules/comma-spacing.ts
      let previousToken = sourceCode.getFirstToken(node);
      for (const element of node.elements) {
        let token: TSESTree.Token | null;
        if (element === null) {
        if (element == null) {
          token = sourceCode.getTokenAfter(previousToken!);
          if (token && isCommaToken(token)) {
            ignoredTokens.add(token);
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
 ): number {
  const type = getNodeType(node);

  if (type === null) {
  if (type == null) {
    // shouldn't happen but just in case, put it on the end
    return orderConfig.length - 1;
  }
            supportsModifiers,
          );

          if (grouped === null) {
          if (grouped == null) {
            return false;
          }

diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
      let name: string | null = originalName;

      name = validateUnderscore('leading', config, name, node, originalName);
      if (name === null) {
      if (name == null) {
        // fail
        return;
      }

      name = validateUnderscore('trailing', config, name, node, originalName);
      if (name === null) {
      if (name == null) {
        // fail
        return;
      }

      name = validateAffix('prefix', config, name, node, originalName);
      if (name === null) {
      if (name == null) {
        // fail
        return;
      }

      name = validateAffix('suffix', config, name, node, originalName);
      if (name === null) {
      if (name == null) {
        // fail
        return;
      }
    modifiers: Set<Modifiers>,
  ): boolean {
    const formats = config.format;
    if (formats === null || formats.length === 0) {
    if (!formats?.length) {
      return true;
    }

  context: Context,
  selector: Selectors,
 ): boolean {
  if (config.types === null) {
  if (config.types == null) {
    return true;
  }

diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
          | TSESTree.FunctionExpression,
      ): void {
        const validator = validators.function;
        if (!validator || node.id === null) {
        if (!validator || node.id == null) {
          return;
        }

        }

        const id = node.id;
        if (id === null) {
        if (id == null) {
          return;
        }

diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
      node: TSESTree.NewExpression | TSESTree.CallExpression,
    ): void {
      const calleeName = getCalleeName(node.callee);
      if (calleeName === null) {
      if (calleeName == null) {
        return;
      }

diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
        }

        case AST_NODE_TYPES.TSNullKeyword:
          return init.type === AST_NODE_TYPES.Literal && init.value === null;
          return init.type === AST_NODE_TYPES.Literal && init.value == null;

        case AST_NODE_TYPES.TSStringKeyword:
          return (
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
  },
  defaultOptions: [],
  create(context) {
    /* istanbul ignore if */ if (baseRule === null) {
    /* istanbul ignore if */ if (baseRule == null) {
      throw new Error(
        '@typescript-eslint/no-loss-of-precision requires at least ESLint v7.1.0',
      );
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts

    function checkVariableDeclaration(node: TSESTree.VariableDeclarator): void {
      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
      if (tsNode.initializer === undefined || node.init === null) {
      if (tsNode.initializer === undefined || node.init == null) {
        return;
      }
      const varType = checker.getTypeAtLocation(tsNode.name);

    function checkReturnStatement(node: TSESTree.ReturnStatement): void {
      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
      if (tsNode.expression === undefined || node.argument === null) {
      if (tsNode.expression === undefined || node.argument == null) {
        return;
      }
      const contextualType = checker.getContextualType(tsNode.expression);
      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
      const value = tsNode.initializer;
      if (
        node.value === null ||
        node.value == null ||
        value === undefined ||
        !ts.isJsxExpression(value) ||
        value.expression === undefined
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts

  const variableDeclarator = definition.node;
  return (
    variableDeclarator.definite === true || variableDeclarator.init !== null
    variableDeclarator.definite === true || variableDeclarator.init != null
  );
 }

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
        | TSESTree.ForStatement
        | TSESTree.WhileStatement,
    ): void {
      if (node.test === null) {
      if (node.test == null) {
        // e.g. `for(;;)`
        return;
      }
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts

      const alias = tryGetAliasedSymbol(symbol, checker);

      return alias !== null && symbolIsNamespaceInScope(alias);
      return alias != null && symbolIsNamespaceInScope(alias);
    }

    function getSymbolInScope(
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts

  if (typeof options === 'string') {
    functions = options !== 'nofunc';
  } else if (typeof options === 'object' && options !== null) {
  } else if (typeof options === 'object' && options != null) {
    functions = options.functions !== false;
    classes = options.classes !== false;
    enums = options.enums !== false;
  reference: TSESLint.Scope.Reference,
 ): boolean {
  return (
    variable.defs[0].type == DefinitionType.TSEnumName &&
    variable.defs[0].type === DefinitionType.TSEnumName &&
    variable.scope.variableScope !== reference.from.variableScope
  );
 }
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
      node: TSESTree.Node | null,
    ): node is TSESTree.VariableDeclaration {
      return (
        node !== null &&
        node.type === AST_NODE_TYPES.VariableDeclaration &&
        node?.type === AST_NODE_TYPES.VariableDeclaration &&
        node.kind !== 'const' &&
        node.declarations.length === 1
      );
    }

    function isZeroInitialized(node: TSESTree.VariableDeclarator): boolean {
      return node.init !== null && isLiteral(node.init, 0);
      return node.init != null && isLiteral(node.init, 0);
    }

    function isMatchingIdentifier(
      name: string,
    ): TSESTree.Expression | null {
      if (
        node !== null &&
        node.type === AST_NODE_TYPES.BinaryExpression &&
        node?.type === AST_NODE_TYPES.BinaryExpression &&
        node.operator === '<' &&
        isMatchingIdentifier(node.left, name) &&
        node.right.type === AST_NODE_TYPES.MemberExpression &&
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
        typeof member.returnType !== 'undefined'
      ) {
        if (
          tsThisTypes !== null &&
          tsThisTypes.length > 0 &&
          tsThisTypes?.length &&
          node.type === AST_NODE_TYPES.TSInterfaceDeclaration
        ) {
          // the message can be confusing if we don't point directly to the `this` node instead of the whole member
        // inside an interface keep track of all ThisType references.
        // unless it's inside a nested type literal in which case it's invalid code anyway
        // we don't want to incorrectly say "it refers to name" while typescript says it's completely invalid.
        if (literalNesting === 0 && tsThisTypes !== null) {
        if (literalNesting === 0 && tsThisTypes != null) {
          tsThisTypes.push(node);
        }
      },
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts

    function isNumber(node: TSESTree.Node, value: number): boolean {
      const evaluated = getStaticValue(node, globalScope);
      return evaluated !== null && evaluated.value === value;
      return evaluated != null && evaluated.value === value;
    }

    function isPositiveCheck(node: TSESTree.BinaryExpression): boolean {
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts

        if (
          argumentNode.type === AST_NODE_TYPES.Literal &&
          typeof argumentNode.value == 'string'
          typeof argumentNode.value === 'string'
        ) {
          const regExp = RegExp(argumentNode.value);
          return context.report({
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
     */
    function isNull(node: TSESTree.Node): node is TSESTree.Literal {
      const evaluated = getStaticValue(node, globalScope);
      return evaluated != null && evaluated.value === null;
      return evaluated != null && evaluated.value == null;
    }

    /**
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
        const unionTypes = unionTypeParts(discriminantType);
        const caseTypes: Set<ts.Type> = new Set();
        for (const switchCase of node.cases) {
          if (switchCase.test === null) {
          if (switchCase.test == null) {
            // Switch has 'default' branch - do nothing.
            return;
          }
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
        }
      },
      Program(node): void {
        if (lib === 'always' && path === 'always' && types == 'always') {
        if (lib === 'always' && path === 'always' && types === 'always') {
          return;
        }
        programNode = node;
diff --git a/packages/eslint-plugin/src/util/isNullLiteral.ts b/packages/eslint-plugin/src/util/isNullLiteral.ts
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';

 export function isNullLiteral(i: TSESTree.Node): boolean {
  return i.type === AST_NODE_TYPES.Literal && i.value === null;
  return i.type === AST_NODE_TYPES.Literal && i.value == null;
 }
diff --git a/packages/eslint-plugin/tests/rules/indent/indent.test.ts b/packages/eslint-plugin/tests/rules/indent/indent.test.ts
          })
          .filter(
            (error): error is TSESLint.TestCaseError<MessageIds> =>
              error !== null,
              error != null,
          ),
      };
      if (invalid.errors.length > 0) {
diff --git a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
  function makeOptional(code: string): string;
  function makeOptional(code: string | null | undefined): string | null;
  function makeOptional(code: string | null | undefined): string | null {
    if (code === null || code === undefined) {
    if (code == null) {
      return null;
    }
    return (
diff --git a/packages/scope-manager/src/ScopeManager.ts b/packages/scope-manager/src/ScopeManager.ts
  protected nestScope<T extends Scope>(scope: T): T;
  protected nestScope(scope: Scope): Scope {
    if (scope instanceof GlobalScope) {
      assert(this.currentScope === null);
      assert(this.currentScope == null);
      this.globalScope = scope;
    }
    this.currentScope = scope;
diff --git a/packages/scope-manager/src/referencer/ClassVisitor.ts b/packages/scope-manager/src/referencer/ClassVisitor.ts
       * }
       */
      if (
        keyName !== null &&
        keyName != null &&
        this.#classNode.body.body.find(
          (node): node is TSESTree.MethodDefinition =>
            node !== methodNode &&
diff --git a/packages/scope-manager/src/referencer/PatternVisitor.ts b/packages/scope-manager/src/referencer/PatternVisitor.ts

    this.#callback(pattern, {
      topLevel: pattern === this.#rootPattern,
      rest:
        lastRestElement !== null &&
        lastRestElement !== undefined &&
        lastRestElement.argument === pattern,
      rest: lastRestElement != null && lastRestElement.argument === pattern,
      assignments: this.#assignments,
    });
  }
diff --git a/packages/scope-manager/src/referencer/Referencer.ts b/packages/scope-manager/src/referencer/Referencer.ts
  }

  private referenceJsxPragma(): void {
    if (this.#jsxPragma === null || this.#hasReferencedJsxFactory) {
    if (this.#jsxPragma == null || this.#hasReferencedJsxFactory) {
      return;
    }
    this.#hasReferencedJsxFactory = this.referenceInSomeUpperScope(

  private referenceJsxFragment(): void {
    if (
      this.#jsxFragmentName === null ||
      this.#jsxFragmentName == null ||
      this.#hasReferencedJsxFragmentFactory
    ) {
      return;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -106,6 +106,13 @@ module.exports = {
		//

		curly: ['error', 'all'],
		eqeqeq: [
		'error',
		'always',
		{
		null: 'never',
		},
		],
		'no-mixed-operators': 'error',
		'no-console': 'error',
		'no-process-exit': 'error',
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -65,7 +65,7 @@ export default util.createRule({
		case AST_NODE_TYPES.TSDeclareFunction:
		case AST_NODE_TYPES.FunctionDeclaration: {
		const name = member.id?.name ?? null;
		if (name === null) {
		if (name == null) {
		return null;
		}
		return {
Expand DownExpand Up		@@ -143,7 +143,7 @@ export default util.createRule({

		members.forEach(member => {
		const method = getMemberMethod(member);
		if (method === null) {
		if (method == null) {
		lastMethod = null;
		return;
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -36,7 +36,7 @@ function stringifyNode(
		function getCustomMessage(
		bannedType: null \| string \| { message?: string; fixWith?: string },
		): string {
		if (bannedType === null) {
		if (bannedType == null) {
		return '';
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -68,7 +68,7 @@ export default createRule<Options, MessageIds>({
		let previousToken = sourceCode.getFirstToken(node);
		for (const element of node.elements) {
		let token: TSESTree.Token \| null;
		if (element === null) {
		if (element == null) {
		token = sourceCode.getTokenAfter(previousToken!);
		if (token && isCommaToken(token)) {
		ignoredTokens.add(token);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -489,7 +489,7 @@ function getRank(
		): number {
		const type = getNodeType(node);

		if (type === null) {
		if (type == null) {
		// shouldn't happen but just in case, put it on the end
		return orderConfig.length - 1;
		}
Expand DownExpand Up		@@ -842,7 +842,7 @@ export default util.createRule<Options, MessageIds>({
		supportsModifiers,
		);

		if (grouped === null) {
		if (grouped == null) {
		return false;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -101,25 +101,25 @@ function createValidator(
		let name: string \| null = originalName;

		name = validateUnderscore('leading', config, name, node, originalName);
		if (name === null) {
		if (name == null) {
		// fail
		return;
		}

		name = validateUnderscore('trailing', config, name, node, originalName);
		if (name === null) {
		if (name == null) {
		// fail
		return;
		}

		name = validateAffix('prefix', config, name, node, originalName);
		if (name === null) {
		if (name == null) {
		// fail
		return;
		}

		name = validateAffix('suffix', config, name, node, originalName);
		if (name === null) {
		if (name == null) {
		// fail
		return;
		}
Expand DownExpand Up		@@ -383,7 +383,7 @@ function createValidator(
		modifiers: Set<Modifiers>,
		): boolean {
		const formats = config.format;
		if (formats === null \|\| formats.length === 0) {
		if (!formats?.length) {
		return true;
		}

Expand DownExpand Up		@@ -427,7 +427,7 @@ function isCorrectType(
		context: Context,
		selector: Selectors,
		): boolean {
		if (config.types === null) {
		if (config.types == null) {
		return true;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -269,7 +269,7 @@ export default util.createRule<Options, MessageIds>({
		\| TSESTree.FunctionExpression,
		): void {
		const validator = validators.function;
		if (!validator \|\| node.id === null) {
		if (!validator \|\| node.id == null) {
		return;
		}

Expand DownExpand Up		@@ -489,7 +489,7 @@ export default util.createRule<Options, MessageIds>({
		}

		const id = node.id;
		if (id === null) {
		if (id == null) {
		return;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -135,7 +135,7 @@ export default util.createRule({
		node: TSESTree.NewExpression \| TSESTree.CallExpression,
		): void {
		const calleeName = getCalleeName(node.callee);
		if (calleeName === null) {
		if (calleeName == null) {
		return;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -147,7 +147,7 @@ export default util.createRule<Options, MessageIds>({
		}

		case AST_NODE_TYPES.TSNullKeyword:
		return init.type === AST_NODE_TYPES.Literal && init.value === null;
		return init.type === AST_NODE_TYPES.Literal && init.value == null;

		case AST_NODE_TYPES.TSStringKeyword:
		return (
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -25,7 +25,7 @@ export default util.createRule<Options, MessageIds>({
		},
		defaultOptions: [],
		create(context) {
		/* istanbul ignore if */ if (baseRule === null) {
		/* istanbul ignore if */ if (baseRule == null) {
		throw new Error(
		'@typescript-eslint/no-loss-of-precision requires at least ESLint v7.1.0',
		);
Expand Down