go-to-type-definition, and find-all-refs should work for import.meta (#44364)

* go-to-type-definition, and find-all-refs should work for import.meta

* search `meta` instead of `import.meta`

* remove `definition`

* fix compilation error

* update baseline

* revert definition

src/services/findAllReferences.ts

@@ -890,6 +890,10 @@ namespace ts.FindAllReferences {
                     node.kind === SyntaxKind.ReadonlyKeyword ? isReadonlyTypeOperator : undefined);
             }
 
+            if (isImportMeta(node.parent) && node.parent.name === node) {
+                return getAllReferencesForImportMeta(sourceFiles, cancellationToken);
+            }
+
             if (isStaticModifier(node) && isClassStaticBlockDeclaration(node.parent)) {
                 return [{ definition: { type: DefinitionKind.Keyword, node }, references: [nodeEntry(node)] }];
             }
@@ -1435,6 +1439,19 @@ namespace ts.FindAllReferences {
             }
         }
 
+        function getAllReferencesForImportMeta(sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] | undefined {
+            const references = flatMap(sourceFiles, sourceFile => {
+                cancellationToken.throwIfCancellationRequested();
+                return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "meta", sourceFile), node => {
+                    const parent = node.parent;
+                    if (isImportMeta(parent)) {
+                        return nodeEntry(parent);
+                    }
+                });
+            });
+            return references.length ? [{ definition: { type: DefinitionKind.Keyword, node: references[0].node }, references }] : undefined;
+        }
+
         function getAllReferencesForKeyword(sourceFiles: readonly SourceFile[], keywordKind: SyntaxKind, cancellationToken: CancellationToken, filter?: (node: Node) => boolean): SymbolAndEntries[] | undefined {
             const references = flatMap(sourceFiles, sourceFile => {
                 cancellationToken.throwIfCancellationRequested();

src/services/goToDefinition.ts

@@ -198,6 +198,10 @@ namespace ts.GoToDefinition {
             return undefined;
         }
 
+        if (isImportMeta(node.parent) && node.parent.name === node) {
+            return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent);
+        }
+
         const symbol = getSymbol(node, typeChecker);
         if (!symbol) return undefined;
 

src/services/services.ts

@@ -1724,6 +1724,9 @@ namespace ts {
             if (isNamedTupleMember(node.parent) && node.pos === node.parent.pos) {
                 return node.parent;
             }
+            if (isImportMeta(node.parent) && node.parent.name === node) {
+                return node.parent;
+            }
             return node;
         }
 
@@ -1740,6 +1743,8 @@ namespace ts {
                 case SyntaxKind.SuperKeyword:
                 case SyntaxKind.NamedTupleMember:
                     return true;
+                case SyntaxKind.MetaProperty:
+                    return isImportMeta(node);
                 default:
                     return false;
             }

tests/baselines/reference/findAllRefsImportMeta.baseline.jsonc

@@ -0,0 +1,61 @@
+// === /tests/cases/fourslash/foo.ts ===
+// /// <reference no-default-lib="true"/>
+// /// <reference path='./bar.d.ts' />
+// import./*FIND ALL REFS*/[|meta|];
+// import.[|meta|];
+
+// === /tests/cases/fourslash/baz.ts ===
+// /// <reference no-default-lib="true"/>
+// /// <reference path='./bar.d.ts' />
+// let x = import
+//   .  // hai :)
+//     [|meta|];
+
+[
+  {
+    "definition": {
+      "containerKind": "",
+      "containerName": "",
+      "fileName": "/tests/cases/fourslash/foo.ts",
+      "kind": "keyword",
+      "textSpan": {
+        "start": 82,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "kind": "keyword"
+        }
+      ]
+    },
+    "references": [
+      {
+        "textSpan": {
+          "start": 82,
+          "length": 4
+        },
+        "fileName": "/tests/cases/fourslash/foo.ts",
+        "isWriteAccess": false,
+        "isDefinition": false
+      },
+      {
+        "textSpan": {
+          "start": 95,
+          "length": 4
+        },
+        "fileName": "/tests/cases/fourslash/foo.ts",
+        "isWriteAccess": false,
+        "isDefinition": false
+      },
+      {
+        "textSpan": {
+          "start": 109,
+          "length": 4
+        },
+        "fileName": "/tests/cases/fourslash/baz.ts",
+        "isWriteAccess": false,
+        "isDefinition": false
+      }
+    ]
+  }
+]

tests/baselines/reference/quickInfoImportMeta.baseline

@@ -0,0 +1,41 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/foo.ts",
+      "position": 77,
+      "name": "1"
+    },
+    "quickInfo": {
+      "kind": "",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 75,
+        "length": 6
+      },
+      "displayParts": [],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/foo.ts",
+      "position": 84,
+      "name": "2"
+    },
+    "quickInfo": {
+      "kind": "interface",
+      "kindModifiers": "declare",
+      "textSpan": {
+        "start": 75,
+        "length": 11
+      },
+      "displayParts": [],
+      "documentation": [
+        {
+          "text": "The type of `import.meta`.\n\nIf you need to declare that a given property exists on `import.meta`,\nthis type may be augmented via interface merging.",
+          "kind": "text"
+        }
+      ]
+    }
+  }
+]

tests/cases/fourslash/findAllRefsImportMeta.ts

@@ -0,0 +1,26 @@
+// @noLib: true
+
+/// <reference path='fourslash.ts'/>
+
+// @module: esnext
+// @Filename: foo.ts
+/////// <reference no-default-lib="true"/>
+/////// <reference path='./bar.d.ts' />
+////import./**/meta;
+////import.[|meta|];
+
+//@Filename: bar.d.ts
+////interface ImportMeta {
+////}
+
+// @Filename: baz.ts
+/////// <reference no-default-lib="true"/>
+/////// <reference path='./bar.d.ts' />
+////let x = import
+////  .  // hai :)
+////    meta;
+
+verify.baselineFindAllReferences("");
+
+goTo.rangeStart(test.ranges()[0]);
+verify.renameInfoFailed();

tests/cases/fourslash/goToDefinitionImportMeta.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+// @module: esnext
+// @Filename: foo.ts
+/////// <reference no-default-lib="true"/>
+/////// <reference path='./bar.d.ts' />
+////import.me/*reference*/ta;
+
+//@Filename: bar.d.ts
+////interface ImportMeta {
+////}
+
+verify.goToDefinition("reference", []);

tests/cases/fourslash/goToTypeDefinitionImportMeta.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+// @module: esnext
+// @Filename: foo.ts
+/////// <reference no-default-lib="true"/>
+/////// <reference path='./bar.d.ts' />
+////import.me/*reference*/ta;
+
+//@Filename: bar.d.ts
+////interface /*definition*/ImportMeta {
+////}
+
+verify.goToType("reference", "definition");

tests/cases/fourslash/quickInfoImportMeta.ts

@@ -0,0 +1,19 @@
+///<reference path="fourslash.ts" />
+
+// @module: esnext
+// @Filename: foo.ts
+/////// <reference no-default-lib="true"/>
+/////// <reference path='./bar.d.ts' />
+////im/*1*/port.me/*2*/ta;
+
+//@Filename: bar.d.ts
+/////**
+//// * The type of `import.meta`.
+//// *
+//// * If you need to declare that a given property exists on `import.meta`,
+//// * this type may be augmented via interface merging.
+//// */
+//// interface ImportMeta {
+////}
+
+verify.baselineQuickInfo()