feat: treat this in typeof this as a ThisExpression

packages/ast-spec/src/unions/EntityName.ts

@@ -1,4 +1,5 @@
 import type { Identifier } from '../expression/Identifier/spec';
+import type { ThisExpression } from '../expression/ThisExpression/spec';
 import type { TSQualifiedName } from '../type/TSQualifiedName/spec';
 
-export type EntityName = Identifier | TSQualifiedName;
+export type EntityName = Identifier | ThisExpression | TSQualifiedName;

packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts

@@ -248,6 +248,16 @@ class Foo {}
     `
 export type AppState = typeof import('./src/store/reducers').default;
     `,
+    `
+let self: typeof this;
+let foo: typeof this.foo;
+const obj = {
+  foo: '',
+  bar() {
+    let self: typeof this;
+  },
+};
+    `,
   ],
   invalid: [
     {

packages/scope-manager/src/referencer/ClassVisitor.ts

@@ -293,7 +293,7 @@ class ClassVisitor extends Visitor {
       node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
       this.#emitDecoratorMetadata
     ) {
-      let identifier: TSESTree.Identifier;
+      let identifier: TSESTree.Identifier | TSESTree.ThisExpression;
       if (
         node.typeAnnotation.typeName.type === AST_NODE_TYPES.TSQualifiedName
       ) {
@@ -306,6 +306,10 @@ class ClassVisitor extends Visitor {
         identifier = node.typeAnnotation.typeName;
       }
 
+      if (identifier.type === AST_NODE_TYPES.ThisExpression) {
+        return;
+      }
+
       if (withDecorators) {
         this.#referencer.currentScope().referenceDualValueType(identifier);
 

packages/scope-manager/src/referencer/TypeVisitor.ts

@@ -256,15 +256,22 @@ class TypeVisitor extends Visitor {
 
   // a type query `typeof foo` is a special case that references a _non-type_ variable,
   protected TSTypeQuery(node: TSESTree.TSTypeQuery): void {
-    if (node.exprName.type === AST_NODE_TYPES.Identifier) {
-      this.#referencer.currentScope().referenceValue(node.exprName);
-    } else {
-      let expr = node.exprName.left;
-      while (expr.type !== AST_NODE_TYPES.Identifier) {
-        expr = expr.left;
+    let identifier: TSESTree.Identifier | TSESTree.ThisExpression;
+    if (node.exprName.type === AST_NODE_TYPES.TSQualifiedName) {
+      let iter = node.exprName;
+      while (iter.left.type === AST_NODE_TYPES.TSQualifiedName) {
+        iter = iter.left;
       }
-      this.#referencer.currentScope().referenceValue(expr);
+      identifier = iter.left;
+    } else {
+      identifier = node.exprName;
+    }
+
+    if (identifier.type === AST_NODE_TYPES.ThisExpression) {
+      return;
     }
+
+    this.#referencer.currentScope().referenceValue(identifier);
   }
 
   protected TSTypeAnnotation(node: TSESTree.TSTypeAnnotation): void {

packages/shared-fixtures/fixtures/typescript/types/typeof-this.src.ts

@@ -0,0 +1,2 @@
+let self: typeof this;
+let foo: typeof this.foo;

packages/typescript-estree/src/convert.ts

@@ -20,6 +20,7 @@ import {
   isComputedProperty,
   isESTreeClassMember,
   isOptional,
+  isThisInTypeQuery,
   TSError,
   unescapeStringLiteralText,
 } from './node-utils';
@@ -799,6 +800,14 @@ export class Converter {
       }
 
       case SyntaxKind.Identifier: {
+        if (isThisInTypeQuery(node)) {
+          return this.createNode<TSESTree.ThisExpression>(
+            node as unknown as ts.ThisExpression,
+            {
+              type: AST_NODE_TYPES.ThisExpression,
+            },
+          );
+        }
         return this.createNode<TSESTree.Identifier>(node, {
           type: AST_NODE_TYPES.Identifier,
           name: node.text,

packages/typescript-estree/src/node-utils.ts

@@ -662,3 +662,29 @@ export function firstDefined<T, U>(
   }
   return undefined;
 }
+
+export function identifierIsThisKeyword(id: ts.Identifier): boolean {
+  return id.originalKeywordKind === SyntaxKind.ThisKeyword;
+}
+
+export function isThisIdentifier(
+  node: ts.Node | undefined,
+): node is ts.Identifier {
+  return (
+    !!node &&
+    node.kind === SyntaxKind.Identifier &&
+    identifierIsThisKeyword(node as ts.Identifier)
+  );
+}
+
+export function isThisInTypeQuery(node: ts.Node): boolean {
+  if (!isThisIdentifier(node)) {
+    return false;
+  }
+
+  while (ts.isQualifiedName(node.parent) && node.parent.left === node) {
+    node = node.parent;
+  }
+
+  return node.parent.kind === SyntaxKind.TypeQuery;
+}

packages/typescript-estree/tests/ast-alignment/utils.ts

@@ -1,6 +1,6 @@
 // babel types are something we don't really care about
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/restrict-plus-operands */
-import type { File, Program } from '@babel/types';
+import type { File, Identifier, Program, TSTypeQuery } from '@babel/types';
 import { AST_NODE_TYPES, TSESTree } from '../../src/ts-estree';
 import { deeplyCopy, omitDeep } from '../../tools/test-utils';
 
@@ -295,6 +295,27 @@ export function preprocessBabylonAST(ast: File): any {
           delete node.loc.start.index;
         }
       },
+      TSTypeQuery(node: TSTypeQuery) {
+        const { exprName } = node;
+        const processIdentifier = (identifier: Identifier) => {
+          if (identifier.name === 'this') {
+            (identifier.type as string) = 'ThisExpression';
+            delete (identifier as { name?: string }).name;
+          }
+        };
+        if (exprName.type === 'Identifier') {
+          processIdentifier(exprName);
+        } else if (exprName.type === 'TSQualifiedName') {
+          let qualifiedName = exprName;
+          while (true) {
+            if (qualifiedName.left.type === 'Identifier') {
+              processIdentifier(qualifiedName.left);
+              return;
+            }
+            qualifiedName = qualifiedName.left;
+          }
+        }
+      },
     },
   );
 }

packages/typescript-estree/tests/lib/__snapshots__/semantic-diagnostics-enabled.test.ts.snap

@@ -2786,6 +2786,8 @@ exports[`Parse all fixtures with "errorOnTypeScriptSyntacticAndSemanticIssues" e
 
 exports[`Parse all fixtures with "errorOnTypeScriptSyntacticAndSemanticIssues" enabled fixtures/typescript/types/typeof.src 1`] = `"TEST OUTPUT: No semantic or syntactic issues found"`;
 
+exports[`Parse all fixtures with "errorOnTypeScriptSyntacticAndSemanticIssues" enabled fixtures/typescript/types/typeof-this.src 1`] = `"TEST OUTPUT: No semantic or syntactic issues found"`;
+
 exports[`Parse all fixtures with "errorOnTypeScriptSyntacticAndSemanticIssues" enabled fixtures/typescript/types/typeof-with-type-parameters.src 1`] = `"TEST OUTPUT: No semantic or syntactic issues found"`;
 
 exports[`Parse all fixtures with "errorOnTypeScriptSyntacticAndSemanticIssues" enabled fixtures/typescript/types/union-intersection.src 1`] = `"TEST OUTPUT: No semantic or syntactic issues found"`;