feat: removeImportsFromReferences (enabled by default!)

Author: zardoy

README.MD

@@ -70,6 +70,12 @@ usersList.map // -> usersList.map((user) => )
 
 <https://github.com/microsoft/vscode/issues/160637>
 
+### Remove Imports From References
+
+(*enabled by default*)
+
+Removes import statements from references when symbol has usages in the same file. Why? Because if export thing is used in another file, it might be obvious that it is imported, and most probably you are not interested in import statements.
+
 ## Minor Useful Features
 
 ### `enablePlugin` setting

src/configurationType.ts

@@ -203,6 +203,10 @@ export type Configuration = {
      * @default true
      */
     removeDefinitionFromReferences: boolean
+    /**
+     * @default true
+     */
+    removeImportsFromReferences: boolean
     /**
      * Small definition improvements by cleaning them out:
      * - remove node_modules definition on React.FC component click

typescript/src/references.ts

@@ -1,5 +1,5 @@
-import type tslib from 'typescript/lib/tsserverlibrary'
 import { GetConfig } from './types'
+import { findChildContainingPositionMaxDepth, approveCast } from './utils'
 
 export default (proxy: ts.LanguageService, languageService: ts.LanguageService, c: GetConfig) => {
     proxy.findReferences = (fileName, position) => {
@@ -11,6 +11,43 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                 references: references.filter(({ isDefinition }) => !isDefinition),
             }))
         }
+        if (c('removeImportsFromReferences')) {
+            const program = languageService.getProgram()!
+            const importsCountPerFileName: Record<
+                string,
+                {
+                    all: number
+                    cur: number
+                }
+            > = {}
+            const allReferences = prior.flatMap(({ references }) => references)
+            allReferences.forEach(({ fileName }) => {
+                importsCountPerFileName[fileName] ??= {
+                    all: 0,
+                    cur: 0,
+                }
+                importsCountPerFileName[fileName]!.all++
+            })
+            prior = prior.map(({ references, ...other }) => {
+                return {
+                    ...other,
+                    references: references.filter(({ fileName, textSpan }) => {
+                        const importsCount = importsCountPerFileName[fileName]!
+                        // doesn't make sense to handle case where it gets imports twice
+                        if (importsCount.all <= 1 || importsCount.cur !== 0) return true
+                        importsCount.cur++
+                        const sourceFile = program.getSourceFile(fileName)
+                        if (!sourceFile) return true
+                        const end = textSpan.start + textSpan.length
+                        let node = findChildContainingPositionMaxDepth(sourceFile, end, 6)
+                        if (!node) return true
+                        if (ts.isIdentifier(node)) node = node.parent
+                        if (approveCast(node, ts.isNamedImports, ts.isImportSpecifier, ts.isImportClause, ts.isImportEqualsDeclaration)) return false
+                        return true
+                    }),
+                }
+            })
+        }
         return prior
     }
 }