feat: New feature: boost name suggestions! Insanely effective & easy

Author: zardoy

typescript/src/completions/boostKeywordSuggestions.ts

@@ -1,4 +1,4 @@
-import { findChildContainingPosition } from '../utils'
+import { boostOrAddSuggestions, findChildContainingPosition } from '../utils'
 
 export default (entries: ts.CompletionEntry[], position: number, node: ts.Node): ts.CompletionEntry[] | undefined => {
     // todo-not-sure for now, requires explicit completion trigger
@@ -22,8 +22,8 @@ export default (entries: ts.CompletionEntry[], position: number, node: ts.Node):
     }
     if (extendsKeyword) addOrBoostKeywords.push('extends')
     if (addOrBoostKeywords.length === 0) return
-    return [
-        ...addOrBoostKeywords.map(keyword => ({ name: keyword, kind: ts.ScriptElementKind.keyword, sortText: '07' })),
-        ...entries.filter(({ name }) => !addOrBoostKeywords.includes(name)),
-    ]
+    return boostOrAddSuggestions(
+        entries,
+        addOrBoostKeywords.map(name => ({ name, kind: ts.ScriptElementKind.keyword })),
+    )
 }

typescript/src/completions/boostNameSuggestions.ts

@@ -0,0 +1,68 @@
+import { boostExistingSuggestions, boostOrAddSuggestions, findChildContainingPosition } from '../utils'
+
+// 1. add suggestions for unresolved indentifiers in code
+// 2. boost identifer or type name suggestion
+export default (
+    entries: ts.CompletionEntry[],
+    position: number,
+    sourceFile: ts.SourceFile,
+    node: ts.Node,
+    languageService: ts.LanguageService,
+): ts.CompletionEntry[] | undefined => {
+    // todo getPreviousPartNode() util
+    // todo object key
+    const fileText = sourceFile.getFullText()
+    const fileTextBeforePos = fileText.slice(0, position)
+    const preConstNodeOffset = fileTextBeforePos.match(/(?:const|let) ([\w\d]*)$/i)?.[1]
+    /** false - pick all identifiers after cursor
+     * node - pick identifiers that within node */
+    let filterBlock: undefined | false | ts.Node
+    if (preConstNodeOffset !== undefined) {
+        const node = findChildContainingPosition(ts, sourceFile, position - preConstNodeOffset.length - 2)
+        if (!node || !ts.isVariableDeclarationList(node)) return
+        filterBlock = false
+    } else if (ts.isIdentifier(node) && node.parent?.parent) {
+        // node > parent1 > parent2
+        let parent1 = node.parent
+        let parent2 = parent1.parent
+        if (ts.isParameter(parent1) && isFunction(parent2)) {
+            filterBlock = parent2.body ?? false
+        }
+        if (ts.isQualifiedName(parent1)) parent1 = parent1.parent
+        parent2 = parent1.parent
+        if (ts.isTypeReferenceNode(parent1) && ts.isParameter(parent2) && isFunction(parent2.parent) && ts.isIdentifier(parent2.name)) {
+            const name = parent2.name.text.replace(/^_/, '')
+            // its name convention in TS
+            const nameUpperFirst = name[0]!.toUpperCase() + name.slice(1)
+            return boostExistingSuggestions(entries, ({ name }) => {
+                if (!name.includes(nameUpperFirst)) return false
+                return true
+            })
+        }
+    }
+
+    if (filterBlock === undefined) return
+    const semanticDiagnostics = languageService.getSemanticDiagnostics(sourceFile.fileName)
+
+    const notFoundIdentifiers = semanticDiagnostics
+        .filter(({ code }) => [2552, 2304].includes(code))
+        .filter(({ start, length }) => {
+            if ([start, length].some(x => x === undefined)) return false
+            if (filterBlock === false) return start! > position
+            const diagnosticEnd = start! + length!
+            const { pos, end } = filterBlock!
+            if (start! < pos) return false
+            if (diagnosticEnd > end) return false
+            return true
+        })
+    const generalNotFoundNames = [...new Set(notFoundIdentifiers.map(({ start, length }) => fileText.slice(start!, start! + length!)))]
+    return boostOrAddSuggestions(
+        entries,
+        generalNotFoundNames.map(name => ({ name, kind: ts.ScriptElementKind.warning })),
+    )
+
+    function isFunction(node: ts.Node): node is ts.ArrowFunction | ts.FunctionDeclaration {
+        if (!node) return false
+        return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node)
+    }
+}

typescript/src/completionsAtPosition.ts

@@ -14,6 +14,7 @@ import objectLiteralHelpers from './completions/objectLiteralHelpers'
 import switchCaseExcludeCovered from './completions/switchCaseExcludeCovered'
 import additionalTypesSuggestions from './completions/additionalTypesSuggestions'
 import boostKeywordSuggestions from './completions/boostKeywordSuggestions'
+import boostTextSuggestions from './completions/boostNameSuggestions'
 
 export type PrevCompletionMap = Record<string, { originalName?: string; documentationOverride?: string | ts.SymbolDisplayPart[] }>
 
@@ -98,6 +99,11 @@ export const getCompletionsAtPosition = (
         prior.entries = [...prior.entries, ...addSignatureAccessCompletions]
     }
 
+    if (leftNode) {
+        const newEntries = boostTextSuggestions(prior?.entries ?? [], position, sourceFile, leftNode, languageService)
+        if (newEntries?.length && ensurePrior() && prior) prior.entries = newEntries
+    }
+
     if (!prior) return
 
     if (c('fixSuggestionsSorting')) prior.entries = fixPropertiesSorting(prior.entries, leftNode, sourceFile, program) ?? prior.entries

typescript/src/utils.ts

@@ -1,4 +1,5 @@
 import type tslib from 'typescript/lib/tsserverlibrary'
+import { SetOptional } from 'type-fest'
 
 export function findChildContainingPosition(
     typescript: typeof import('typescript/lib/tsserverlibrary'),
@@ -63,6 +64,25 @@ export const cleanupEntryName = ({ name }: Pick<ts.CompletionEntry, 'name'>) =>
     return name.replace(/^★ /, '')
 }
 
+export const boostOrAddSuggestions = (existingEntries: ts.CompletionEntry[], topEntries: SetOptional<ts.CompletionEntry, 'sortText'>[]) => {
+    const topEntryNames = topEntries.map(({ name }) => name)
+    return [
+        ...topEntries.map(entry => ({ ...entry, sortText: entry.sortText ?? `07` })),
+        ...existingEntries.filter(({ name }) => !topEntryNames.includes(name)),
+    ]
+}
+
+export const boostExistingSuggestions = (entries: ts.CompletionEntry[], predicate: (entry: ts.CompletionEntry) => boolean | number) => {
+    return [...entries].sort((a, b) => {
+        return [a, b]
+            .map(x => {
+                const res = predicate(x)
+                return res === true ? 0 : res === false ? 1 : res
+            })
+            .reduce((a, b) => a - b)
+    })
+}
+
 // Workaround esbuild bundle modules
 export const nodeModules = __WEB__
     ? null