feat: add in keyword completions

Don't see a reason too add a setting to disable them. There are awesome!

Author: zardoy

typescript/src/completionsAtPosition.ts

@@ -1,5 +1,6 @@
 import _ from 'lodash'
 import type tslib from 'typescript/lib/tsserverlibrary'
+import inKeywordCompletions from './inKeywordCompletions'
 import * as emmet from '@vscode/emmet-helper'
 import isInBannedPosition from './isInBannedPosition'
 import { GetConfig } from './types'
@@ -165,6 +166,17 @@ export const getCompletionsAtPosition = (
             return !banAutoImportPackages.includes(text)
         })
 
+    const result = inKeywordCompletions(position, fileName, node, sourceFile, program, languageService, ts)
+    if (result) {
+        prior.entries.push(...result.completions)
+        Object.assign(
+            prevCompletionsMap,
+            _.mapValues(result.docPerCompletion, value => ({
+                documentationOverride: value,
+            })),
+        )
+    }
+
     if (c('suggestions.keywordsInsertText') === 'space') {
         const charAhead = scriptSnapshot.getText(position, position + 1)
         const bannedKeywords = [

typescript/src/inKeywordCompletions.ts

@@ -0,0 +1,75 @@
+import type tslib from 'typescript/lib/tsserverlibrary'
+
+export default (
+    position: number,
+    fileName: string,
+    node: tslib.Node | undefined,
+    sourceFile: tslib.SourceFile,
+    program: tslib.Program,
+    languageService: tslib.LanguageService,
+    ts: typeof tslib,
+) => {
+    if (!node) return
+    function isBinaryExpression(node: ts.Node): node is ts.BinaryExpression {
+        return node.kind === ts.SyntaxKind.BinaryExpression
+    }
+    const typeChecker = program.getTypeChecker()
+    // TODO info diagnostic if used that doesn't exist
+    if (
+        ts.isStringLiteralLike(node) &&
+        isBinaryExpression(node.parent) &&
+        node.parent.left === node &&
+        node.parent.operatorToken.kind === ts.SyntaxKind.InKeyword
+    ) {
+        const quote = node.getText()[0]!
+        const type = typeChecker.getTypeAtLocation(node.parent.right)
+        const suggestions: Record<
+            string,
+            {
+                insertText: string
+                usingDisplayIndexes: number[]
+                documentations: string[]
+            }
+        > = {}
+        const unitedTypes = type.isUnion() ? type.types : [type]
+        for (let [typeIndex, localType] of unitedTypes.entries()) {
+            // TODO set deprecated tag
+            for (let prop of localType.getProperties()) {
+                const { name } = prop
+                if (!suggestions[name])
+                    suggestions[name] = {
+                        insertText: prop.name.replace(quote, `\\${quote}`),
+                        usingDisplayIndexes: [],
+                        documentations: [],
+                    }
+                suggestions[name]!.usingDisplayIndexes.push(typeIndex + 1)
+                // const doc = prop.getDocumentationComment(typeChecker)
+                const declaration = prop.getDeclarations()?.[0]
+                suggestions[name]!.documentations.push(
+                    `${typeIndex + 1}: ${declaration && typeChecker.typeToString(typeChecker.getTypeAtLocation(declaration))}`,
+                )
+            }
+        }
+        const docPerCompletion: Record<string, string> = {}
+        const completions: ts.CompletionEntry[] = Object.entries(suggestions)
+            .map(([originaName, { insertText, usingDisplayIndexes, documentations }], i) => {
+                const name = unitedTypes.length > 1 && usingDisplayIndexes.length === 1 ? `☆${originaName}` : originaName
+                docPerCompletion[name] = documentations.join('\n\n')
+                return {
+                    // ⚀ ⚁ ⚂ ⚃ ⚄ ⚅
+                    name: name,
+                    kind: ts.ScriptElementKind.string,
+                    insertText,
+                    sourceDisplay: [{ kind: 'text', text: usingDisplayIndexes.join(', ') }],
+                    sortText: `${usingDisplayIndexes.length}_${i}`,
+                }
+            })
+            .sort((a, b) => a.sortText.localeCompare(b.sortText))
+        return {
+            completions,
+            // make lazy?
+            docPerCompletion,
+        }
+    }
+    return
+}

typescript/src/index.ts

@@ -66,7 +66,8 @@ export = function ({ typescript }: { typescript: typeof import('typescript/lib/t
                         name: entryName,
                         kind: ts.ScriptElementKind.alias,
                         kindModifiers: '',
-                        displayParts: typeof documentationOverride === 'string' ? [{ kind: 'text', text: documentationOverride }] : documentationOverride,
+                        displayParts: [],
+                        documentation: typeof documentationOverride === 'string' ? [{ kind: 'text', text: documentationOverride }] : documentationOverride,
                     }
                 }
                 const prior = info.languageService.getCompletionEntryDetails(

typescript/src/typeCompletions.ts

@@ -0,0 +1,20 @@
+import type tslib from 'typescript/lib/tsserverlibrary'
+
+export default (
+    position: number,
+    fileName: string,
+    node: tslib.Node | undefined,
+    sourceFile: tslib.SourceFile,
+    program: tslib.Program,
+    languageService: tslib.LanguageService,
+    ts: typeof tslib,
+) => {
+    if (!node) return
+}
+
+// spec isnt strict as well
+export const notStrictStringCompletion = (entry: tslib.CompletionEntry): tslib.CompletionEntry => ({
+    ...entry,
+    name: `◯${entry.name}`,
+    insertText: entry.insertText ?? entry.name,
+})

typescript/test/completions.spec.ts

@@ -1,3 +1,4 @@
+import { pickObj } from '@zardoy/utils'
 import { createLanguageService } from '../src/dummyLanguageService'
 import { getCompletionsAtPosition as getCompletionsAtPositionRaw } from '../src/completionsAtPosition'
 import type {} from 'vitest/globals'
@@ -26,9 +27,10 @@ const newFileContents = (contents: string, fileName = entrypoint) => {
 //@ts-ignore
 const defaultConfigFunc = await getDefaultConfigFunc()
 
-const getCompletionsAtPosition = (pos: number, fileName = entrypoint) => {
+const getCompletionsAtPosition = (pos: number, { fileName = entrypoint, shouldHave }: { fileName?: string; shouldHave?: boolean } = {}) => {
     if (pos === undefined) throw new Error('getCompletionsAtPosition: pos is undefined')
     const result = getCompletionsAtPositionRaw(fileName, pos, {}, defaultConfigFunc, languageService, ts.ScriptSnapshot.fromString(files[entrypoint]), ts)
+    if (shouldHave) expect(result).not.toBeUndefined()
     if (!result) return
     return {
         ...result,
@@ -59,3 +61,66 @@ test.skip('Remove Useless Function Props', () => {
     console.log(entryNames)
     // expect(entryNames).not.includes('bind')
 })
+
+test('In Keyword Completions', () => {
+    const [pos] = newFileContents(/* ts */ `
+        const a: { a: boolean, b: string } | { a: number, c: number } = {} as any
+        if ('/*|*/' in a) {}
+    `)
+    const completion = pickObj(getCompletionsAtPosition(pos, { shouldHave: true })!, 'entries', 'prevCompletionsMap')
+    expect(completion).toMatchInlineSnapshot(`
+      {
+        "entries": [
+          {
+            "insertText": "b",
+            "kind": "string",
+            "name": "☆b",
+            "sortText": "1_10",
+            "sourceDisplay": [
+              {
+                "kind": "text",
+                "text": "1",
+              },
+            ],
+          },
+          {
+            "insertText": "c",
+            "kind": "string",
+            "name": "☆c",
+            "sortText": "1_21",
+            "sourceDisplay": [
+              {
+                "kind": "text",
+                "text": "2",
+              },
+            ],
+          },
+          {
+            "insertText": "a",
+            "kind": "string",
+            "name": "a",
+            "sortText": "2_02",
+            "sourceDisplay": [
+              {
+                "kind": "text",
+                "text": "1, 2",
+              },
+            ],
+          },
+        ],
+        "prevCompletionsMap": {
+          "a": {
+            "documentationOverride": "1: boolean
+
+      2: number",
+          },
+          "☆b": {
+            "documentationOverride": "1: string",
+          },
+          "☆c": {
+            "documentationOverride": "2: number",
+          },
+        },
+      }
+    `)
+})