Jul 7, 2023 · Jan 31, 2023 · Jan 31, 2023 · Feb 4, 2023 · Feb 5, 2023 · Feb 7, 2023
diff --git a/packages/ast-spec/src/expression/BinaryExpression/BinaryOperatorToText.ts b/packages/ast-spec/src/expression/BinaryExpression/BinaryOperatorToText.ts
 import type { SyntaxKind } from 'typescript';

 // the members of ts.BinaryOperator
 export interface BinaryOperatorToText {
  [SyntaxKind.InstanceOfKeyword]: 'instanceof';
  [SyntaxKind.InKeyword]: 'in';

  // math
  [SyntaxKind.AsteriskAsteriskToken]: '**';
  [SyntaxKind.AsteriskToken]: '*';
  [SyntaxKind.SlashToken]: '/';
  [SyntaxKind.PercentToken]: '%';
  [SyntaxKind.PlusToken]: '+';
  [SyntaxKind.MinusToken]: '-';

  // bitwise
  [SyntaxKind.AmpersandToken]: '&';
  [SyntaxKind.BarToken]: '|';
  [SyntaxKind.CaretToken]: '^';
  [SyntaxKind.LessThanLessThanToken]: '<<';
  [SyntaxKind.GreaterThanGreaterThanToken]: '>>';
  [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';

  // logical
  [SyntaxKind.AmpersandAmpersandToken]: '&&';
  [SyntaxKind.BarBarToken]: '||';
  [SyntaxKind.LessThanToken]: '<';
  [SyntaxKind.LessThanEqualsToken]: '<=';
  [SyntaxKind.GreaterThanToken]: '>';
  [SyntaxKind.GreaterThanEqualsToken]: '>=';
  [SyntaxKind.EqualsEqualsToken]: '==';
  [SyntaxKind.EqualsEqualsEqualsToken]: '===';
  [SyntaxKind.ExclamationEqualsEqualsToken]: '!==';
  [SyntaxKind.ExclamationEqualsToken]: '!=';
 }
diff --git a/packages/ast-spec/src/expression/BinaryExpression/spec.ts b/packages/ast-spec/src/expression/BinaryExpression/spec.ts
 import type { BaseNode } from '../../base/BaseNode';
 import type { PrivateIdentifier } from '../../special/PrivateIdentifier/spec';
 import type { Expression } from '../../unions/Expression';
 import type { ValueOf } from '../../utils';
 import type { BinaryOperatorToText } from './BinaryOperatorToText';

 export * from './BinaryOperatorToText';

 export interface BinaryExpression extends BaseNode {
  type: AST_NODE_TYPES.BinaryExpression;
  operator:string;
  operator:ValueOf<BinaryOperatorToText>;
  left: Expression | PrivateIdentifier;
  right: Expression;
 }
diff --git a/packages/ast-spec/tests/BinaryOperatorToText.type-test.ts b/packages/ast-spec/tests/BinaryOperatorToText.type-test.ts
 import type {
  AssignmentOperator,
  BinaryOperator,
  SyntaxKind,
 } from 'typescript';

 import type { BinaryOperatorToText } from '../src';

 type BinaryOperatorWithoutInvalidTypes = Exclude<
  BinaryOperator,
  | AssignmentOperator // --> AssignmentExpression
  | SyntaxKind.CommaToken // -> SequenceExpression
  | SyntaxKind.QuestionQuestionToken // -> LogicalExpression
 >;
 type _Test = {
  readonly [T in BinaryOperatorWithoutInvalidTypes]: BinaryOperatorToText[T];
  // If there are any BinaryOperator members that don't have a corresponding
  // BinaryOperatorToText, then this line will error with "Type 'T' cannot
  // be used to index type 'BinaryOperatorToText'."
 };
diff --git a/packages/eslint-plugin/docs/rules/prefer-optional-chain.md b/packages/eslint-plugin/docs/rules/prefer-optional-chain.md

 <!--/tabs-->

 :::note
 There are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
 :::
 ## Options

 In the context of the descriptions below a "loose boolean" operand is any operand that implicitly coerces the value to a boolean.
 Specifically the argument of the not operator (`!loose`) or a bare value in a logical expression (`loose && looser`).

 ### `allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing`

 When this option is `true`, the rule will not provide an auto-fixer for cases where the return type of the expression would change. For example for the expression `!foo || foo.bar` the return type of the expression is `true | T`, however for the equivalent optional chain `foo?.bar` the return type of the expression is `undefined | T`. Thus changing the code from a logical expression to an optional chain expression has altered the type of the expression.

 In some cases this distinction _may_ matter - which is why these fixers are considered unsafe - they may break the build! For example in the following code:

 ```ts
 declare const foo: { bar: boolean } | null | undefined;
 declare function acceptsBoolean(arg: boolean): void;

 // ✅ typechecks succesfully as the expression only returns `boolean`
 acceptsBoolean(foo != null && foo.bar);

 // ❌ typechecks UNSUCCESSFULLY as the expression returns `boolean | undefined`
 acceptsBoolean(foo != null && foo.bar);
 ```

 This style of code isn't super common - which means having this option set to `true` _should_ be safe in most codebases. However we default it to `false` due to its unsafe nature. We have provided this option for convenience because it increases the autofix cases covered by the rule. If you set option to `true` the onus is entirely on you and your team to ensure that each fix is correct and safe and that it does not break the build.

 When this option is `false` unsafe cases will have suggestion fixers provided instead of auto-fixers - meaning you can manually apply the fix using your IDE tooling.

 ### `checkAny`

 When this option is `true` the rule will check operands that are typed as `any` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkAny: true`

 ```ts
 declare const thing: any;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkAny: false`

 ```ts
 declare const thing: any;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `checkUnknown`

 When this option is `true` the rule will check operands that are typed as `unknown` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkUnknown: true`

 ```ts
 declare const thing: unknown;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkUnknown: false`

 ```ts
 declare const thing: unknown;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `checkString`

 When this option is `true` the rule will check operands that are typed as `string` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkString: true`

 ```ts
 declare const thing: string;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkString: false`

 ```ts
 declare const thing: string;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `checkNumber`

 When this option is `true` the rule will check operands that are typed as `number` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkNumber: true`

 ```ts
 declare const thing: number;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkNumber: false`

 ```ts
 declare const thing: number;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `checkBoolean`

 When this option is `true` the rule will check operands that are typed as `boolean` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkBoolean: true`

 ```ts
 declare const thing: boolean;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkBoolean: false`

 ```ts
 declare const thing: boolean;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `checkBigInt`

 When this option is `true` the rule will check operands that are typed as `bigint` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `checkBigInt: true`

 ```ts
 declare const thing: bigint;

 thing && thing.toString();
 ```

 #### ✅ Correct for `checkBigInt: false`

 ```ts
 declare const thing: bigint;

 thing && thing.toString();
 ```

 <!--/tabs-->

 ### `requireNullish`

 When this option is `true` the rule will skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.

 <!--tabs-->

 #### ❌ Incorrect for `requireNullish: true`

 ```ts
 declare const thing1: string | null;
 thing1 && thing1.toString();
 ```

 #### ✅ Correct for `requireNullish: true`

 ```ts
 declare const thing1: string | null;
 thing1?.toString();

 declare const thing2: string;
 thing2 && thing2.toString();
 ```

 <!--/tabs-->

 ## When Not To Use It

 If you don't mind using more explicit `&&`s, you don't need this rule.
 If you don't mind using more explicit `&&`s/`||`s, you don't need this rule.

 ## Further Reading

diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
    "generate:configs": "yarn tsx tools/generate-configs.ts",
    "lint": "nx lint",
    "test": "jest --coverage",
    "test-single": "jest --no-coverage",
    "typecheck": "tsc -p tsconfig.json --noEmit"
  },
  "dependencies": {
    "@eslint-community/regexpp": "^4.5.0",
    "@typescript-eslint/scope-manager": "5.61.0",
    "@typescript-eslint/type-utils": "5.61.0",
    "@typescript-eslint/utils": "5.61.0",
    "@typescript-eslint/visitor-keys": "5.61.0",
    "debug": "^4.3.4",
    "grapheme-splitter": "^1.0.4",
    "graphemer": "^1.4.0",
diff --git a/packages/eslint-plugin/src/configs/disable-type-checked.ts b/packages/eslint-plugin/src/configs/disable-type-checked.ts
    '@typescript-eslint/non-nullable-type-assertion-style': 'off',
    '@typescript-eslint/prefer-includes': 'off',
    '@typescript-eslint/prefer-nullish-coalescing': 'off',
    '@typescript-eslint/prefer-optional-chain': 'off',
    '@typescript-eslint/prefer-readonly': 'off',
    '@typescript-eslint/prefer-readonly-parameter-types': 'off',
    '@typescript-eslint/prefer-reduce-type-parameter': 'off',
diff --git a/packages/eslint-plugin/src/configs/stylistic.ts b/packages/eslint-plugin/src/configs/stylistic.ts
    '@typescript-eslint/prefer-for-of': 'error',
    '@typescript-eslint/prefer-function-type': 'error',
    '@typescript-eslint/prefer-namespace-keyword': 'error',
    '@typescript-eslint/prefer-optional-chain': 'error',
  },
 };
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
          if (
            node.kind !== 'get' ||
            !node.value.body ||
 !node.value.body.body.length
            node.value.body.body.length === 0
          ) {
            return;
          }
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
     * Checks if a function name is allowed and should not be checked.
     */
    function isAllowedName(node: TSESTree.Node | undefined): boolean {
      if (!node || !options.allowedNames ||!options.allowedNames.length) {
      if (!node || !options.allowedNames || options.allowedNames.length === 0) {
        return false;
      }

diff --git a/packages/eslint-plugin/src/rules/indent.ts b/packages/eslint-plugin/src/rules/indent.ts
        // transform it to a BinaryExpression
        return rules['BinaryExpression, LogicalExpression']({
          type: AST_NODE_TYPES.BinaryExpression,
          operator: 'as',
          operator: 'as' as any,
          left: node.expression,
          // the first typeAnnotation includes the as token
          right: node.typeAnnotation as any,
          test: {
            parent: node,
            type: AST_NODE_TYPES.BinaryExpression,
            operator: 'extends',
            operator: 'extends' as any,
            left: node.checkType as any,
            right: node.extendsType as any,

diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
    ): boolean => {
      return !!(
        allowWithDecorator &&
        node &&
        node.decorators &&
        node.decorators.length
        node?.decorators &&
        node.decorators.length !== 0
      );
    };

diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
          .getProperty('includes')
          ?.getDeclarations();
        if (
          includesMethodDecl == null ||
          !includesMethodDecl.some(includesMethodDecl =>
          !includesMethodDecl?.some(includesMethodDecl =>
            hasSameParameters(includesMethodDecl, instanceofMethodDecl),
          )
        ) {
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts
 export type PreferOptionalChainMessageIds =
  | 'preferOptionalChain'
  | 'optionalChainSuggest';

 export interface PreferOptionalChainOptions {
  checkAny?: boolean;
  checkUnknown?: boolean;
  checkString?: boolean;
  checkNumber?: boolean;
  checkBoolean?: boolean;
  checkBigInt?: boolean;
  requireNullish?: boolean;
  allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean;
 }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,35 @@
		import type { SyntaxKind } from 'typescript';

		// the members of ts.BinaryOperator
		export interface BinaryOperatorToText {
		[SyntaxKind.InstanceOfKeyword]: 'instanceof';
		[SyntaxKind.InKeyword]: 'in';

		// math
		[SyntaxKind.AsteriskAsteriskToken]: '**';
		[SyntaxKind.AsteriskToken]: '*';
		[SyntaxKind.SlashToken]: '/';
		[SyntaxKind.PercentToken]: '%';
		[SyntaxKind.PlusToken]: '+';
		[SyntaxKind.MinusToken]: '-';

		// bitwise
		[SyntaxKind.AmpersandToken]: '&';
		[SyntaxKind.BarToken]: '\|';
		[SyntaxKind.CaretToken]: '^';
		[SyntaxKind.LessThanLessThanToken]: '<<';
		[SyntaxKind.GreaterThanGreaterThanToken]: '>>';
		[SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';

		// logical
		[SyntaxKind.AmpersandAmpersandToken]: '&&';
		[SyntaxKind.BarBarToken]: '\|\|';
		[SyntaxKind.LessThanToken]: '<';
		[SyntaxKind.LessThanEqualsToken]: '<=';
		[SyntaxKind.GreaterThanToken]: '>';
		[SyntaxKind.GreaterThanEqualsToken]: '>=';
		[SyntaxKind.EqualsEqualsToken]: '==';
		[SyntaxKind.EqualsEqualsEqualsToken]: '===';
		[SyntaxKind.ExclamationEqualsEqualsToken]: '!==';
		[SyntaxKind.ExclamationEqualsToken]: '!=';
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,10 +2,14 @@ import type { AST_NODE_TYPES } from '../../ast-node-types';
		import type { BaseNode } from '../../base/BaseNode';
		import type { PrivateIdentifier } from '../../special/PrivateIdentifier/spec';
		import type { Expression } from '../../unions/Expression';
		import type { ValueOf } from '../../utils';
		import type { BinaryOperatorToText } from './BinaryOperatorToText';

		export * from './BinaryOperatorToText';

		export interface BinaryExpression extends BaseNode {
		type: AST_NODE_TYPES.BinaryExpression;
		operator:string;
		operator:ValueOf<BinaryOperatorToText>;
		left: Expression \| PrivateIdentifier;
		right: Expression;
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,20 @@
		import type {
		AssignmentOperator,
		BinaryOperator,
		SyntaxKind,
		} from 'typescript';

		import type { BinaryOperatorToText } from '../src';

		type BinaryOperatorWithoutInvalidTypes = Exclude<
		BinaryOperator,
		\| AssignmentOperator // --> AssignmentExpression
		\| SyntaxKind.CommaToken // -> SequenceExpression
		\| SyntaxKind.QuestionQuestionToken // -> LogicalExpression
		>;
		type _Test = {
		readonly [T in BinaryOperatorWithoutInvalidTypes]: BinaryOperatorToText[T];
		// If there are any BinaryOperator members that don't have a corresponding
		// BinaryOperatorToText, then this line will error with "Type 'T' cannot
		// be used to index type 'BinaryOperatorToText'."
		};
Original file line number	Diff line number	Diff line change
Expand Up		@@ -57,13 +57,204 @@ foo?.a?.b?.c?.d?.e;

		<!--/tabs-->

		:::note
		There are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
		:::
		## Options

		In the context of the descriptions below a "loose boolean" operand is any operand that implicitly coerces the value to a boolean.
		Specifically the argument of the not operator (`!loose`) or a bare value in a logical expression (`loose && looser`).

		### `allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing`

		When this option is `true`, the rule will not provide an auto-fixer for cases where the return type of the expression would change. For example for the expression `!foo \|\| foo.bar` the return type of the expression is `true \| T`, however for the equivalent optional chain `foo?.bar` the return type of the expression is `undefined \| T`. Thus changing the code from a logical expression to an optional chain expression has altered the type of the expression.

		In some cases this distinction _may_ matter - which is why these fixers are considered unsafe - they may break the build! For example in the following code:

		```ts
		declare const foo: { bar: boolean } \| null \| undefined;
		declare function acceptsBoolean(arg: boolean): void;

		// ✅ typechecks succesfully as the expression only returns `boolean`
		acceptsBoolean(foo != null && foo.bar);

		// ❌ typechecks UNSUCCESSFULLY as the expression returns `boolean \| undefined`
		acceptsBoolean(foo != null && foo.bar);
		```

		This style of code isn't super common - which means having this option set to `true` _should_ be safe in most codebases. However we default it to `false` due to its unsafe nature. We have provided this option for convenience because it increases the autofix cases covered by the rule. If you set option to `true` the onus is entirely on you and your team to ensure that each fix is correct and safe and that it does not break the build.

		When this option is `false` unsafe cases will have suggestion fixers provided instead of auto-fixers - meaning you can manually apply the fix using your IDE tooling.

		### `checkAny`

		When this option is `true` the rule will check operands that are typed as `any` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkAny: true`

		```ts
		declare const thing: any;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkAny: false`

		```ts
		declare const thing: any;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `checkUnknown`

		When this option is `true` the rule will check operands that are typed as `unknown` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkUnknown: true`

		```ts
		declare const thing: unknown;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkUnknown: false`

		```ts
		declare const thing: unknown;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `checkString`

		When this option is `true` the rule will check operands that are typed as `string` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkString: true`

		```ts
		declare const thing: string;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkString: false`

		```ts
		declare const thing: string;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `checkNumber`

		When this option is `true` the rule will check operands that are typed as `number` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkNumber: true`

		```ts
		declare const thing: number;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkNumber: false`

		```ts
		declare const thing: number;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `checkBoolean`

		When this option is `true` the rule will check operands that are typed as `boolean` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkBoolean: true`

		```ts
		declare const thing: boolean;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkBoolean: false`

		```ts
		declare const thing: boolean;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `checkBigInt`

		When this option is `true` the rule will check operands that are typed as `bigint` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `checkBigInt: true`

		```ts
		declare const thing: bigint;

		thing && thing.toString();
		```

		#### ✅ Correct for `checkBigInt: false`

		```ts
		declare const thing: bigint;

		thing && thing.toString();
		```

		<!--/tabs-->

		### `requireNullish`

		When this option is `true` the rule will skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.

		<!--tabs-->

		#### ❌ Incorrect for `requireNullish: true`

		```ts
		declare const thing1: string \| null;
		thing1 && thing1.toString();
		```

		#### ✅ Correct for `requireNullish: true`

		```ts
		declare const thing1: string \| null;
		thing1?.toString();

		declare const thing2: string;
		thing2 && thing2.toString();
		```

		<!--/tabs-->

		## When Not To Use It

		If you don't mind using more explicit `&&`s, you don't need this rule.
		If you don't mind using more explicit `&&`s/`\|\|`s, you don't need this rule.

		## Further Reading

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -51,13 +51,15 @@
		"generate:configs": "yarn tsx tools/generate-configs.ts",
		"lint": "nx lint",
		"test": "jest --coverage",
		"test-single": "jest --no-coverage",
		"typecheck": "tsc -p tsconfig.json --noEmit"
		},
		"dependencies": {
		"@eslint-community/regexpp": "^4.5.0",
		"@typescript-eslint/scope-manager": "5.61.0",
		"@typescript-eslint/type-utils": "5.61.0",
		"@typescript-eslint/utils": "5.61.0",
		"@typescript-eslint/visitor-keys": "5.61.0",
		"debug": "^4.3.4",
		"grapheme-splitter": "^1.0.4",
		"graphemer": "^1.4.0",
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -37,6 +37,7 @@ export = {
		'@typescript-eslint/non-nullable-type-assertion-style': 'off',
		'@typescript-eslint/prefer-includes': 'off',
		'@typescript-eslint/prefer-nullish-coalescing': 'off',
		'@typescript-eslint/prefer-optional-chain': 'off',
		'@typescript-eslint/prefer-readonly': 'off',
		'@typescript-eslint/prefer-readonly-parameter-types': 'off',
		'@typescript-eslint/prefer-reduce-type-parameter': 'off',
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -24,6 +24,5 @@ export = {
		'@typescript-eslint/prefer-for-of': 'error',
		'@typescript-eslint/prefer-function-type': 'error',
		'@typescript-eslint/prefer-namespace-keyword': 'error',
		'@typescript-eslint/prefer-optional-chain': 'error',
		},
		};
Original file line number	Diff line number	Diff line change
Expand Up		@@ -65,7 +65,7 @@ export default util.createRule<Options, MessageIds>({
		if (
		node.kind !== 'get' \|\|
		!node.value.body \|\|
		!node.value.body.body.length
		node.value.body.body.length === 0
		) {
		return;
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -229,7 +229,7 @@ export default util.createRule<Options, MessageIds>({
		* Checks if a function name is allowed and should not be checked.
		*/
		function isAllowedName(node: TSESTree.Node \| undefined): boolean {
		if (!node \|\| !options.allowedNames \|\|!options.allowedNames.length) {
		if (!node \|\| !options.allowedNames \|\| options.allowedNames.length === 0) {
		return false;
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -198,7 +198,7 @@ export default util.createRule<Options, MessageIds>({
		// transform it to a BinaryExpression
		return rules['BinaryExpression, LogicalExpression']({
		type: AST_NODE_TYPES.BinaryExpression,
		operator: 'as',
		operator: 'as' as any,
		left: node.expression,
		// the first typeAnnotation includes the as token
		right: node.typeAnnotation as any,
Expand All		@@ -217,7 +217,7 @@ export default util.createRule<Options, MessageIds>({
		test: {
		parent: node,
		type: AST_NODE_TYPES.BinaryExpression,
		operator: 'extends',
		operator: 'extends' as any,
		left: node.checkType as any,
		right: node.extendsType as any,

Expand Down