feat: string template type completions!

e.g. `const a: `foo_${string}_bar` = '/*now completes!*/'`

Author: zardoy

typescript/src/completions/filterJsxComponents.ts

@@ -108,7 +108,7 @@ export default (entries: ts.CompletionEntry[], node: ts.Node, position: number,
         const entryType = typeChecker.getTypeOfSymbolAtLocation(symbol, node)
         typeAtLocLog[entry.name] = nowGetter.now() - mark
         addMark('getTypeAtLocation')
-        // todo setting to allow any!
+        // todo setting to allow any?
         if (entryType.flags & ts.TypeFlags.Any) return false
         // startMark()
         const signatures = typeChecker.getSignaturesOfType(entryType, ts.SignatureKind.Call)
@@ -123,10 +123,10 @@ export default (entries: ts.CompletionEntry[], node: ts.Node, position: number,
     const newEntries = entries.filter(entry => {
         // if (!entry.name[0] || entry.name[0].toLowerCase() === entry.name[0]) return false
         if (entry.kind === ts.ScriptElementKind.keyword) return false
-        // todo
+        // todo?
         if (c('jsxImproveElementsSuggestions.filterNamespaces') && entry.kind === ts.ScriptElementKind.moduleElement) return false
         if (!c('experiments.excludeNonJsxCompletions')) return true
-        // todo!!!
+        // I'm not inrested personally
         if (entry.kind === ts.ScriptElementKind.classElement) return false
         if (entry.kind === ts.ScriptElementKind.localClassElement) return false
         if (!interestedKinds.includes(entry.kind)) return true

typescript/src/completions/stringTemplateType.ts

@@ -0,0 +1,46 @@
+import { compact } from '@zardoy/utils'
+import { sharedCompletionContext } from './sharedContext'
+
+export default (): ts.CompletionEntry[] | void => {
+    const { program } = sharedCompletionContext
+    let { node } = sharedCompletionContext
+    if (!node || !ts.isStringLiteralLike(node)) return
+    const checker = program.getTypeChecker()!
+    let type: ts.Type
+    let objType: ts.Type | undefined
+    if (ts.isElementAccessExpression(node.parent)) {
+        objType = checker.getTypeAtLocation(node.parent.expression)
+    } else if (ts.isPropertyAssignment(node.parent) && ts.isObjectLiteralExpression(node.parent.parent)) {
+        objType = checker.getContextualType(node.parent.parent) ?? checker.getTypeAtLocation(node.parent.parent)
+    }
+    if (objType) {
+        const [indexInfo] = checker.getIndexInfosOfType(objType)
+        if (indexInfo) {
+            type = indexInfo.keyType
+        }
+    }
+    type ??= checker.getContextualType(node) ?? checker.getTypeAtLocation(node)
+    const types = type.isUnion() ? type.types : [type]
+    if (types.some(type => type.flags & ts.TypeFlags.TemplateLiteral)) {
+        return compact(
+            types.map(type => {
+                if (!(type.flags & ts.TypeFlags.TemplateLiteral)) return
+
+                const {
+                    texts: [head, ...spans],
+                } = type as ts.TemplateLiteralType
+                const texts = [head!, ...spans.flatMap(span => (span === '' ? [''] : ['', span]))]
+                let tabStop = 1
+                return {
+                    kind: ts.ScriptElementKind.string,
+                    name: texts.map(text => (text === '' ? '|' : text)).join(''),
+                    sortText: '07',
+                    insertText: texts.map(text => (text === '' ? `$${tabStop++}` : text.replace(/\$/g, '\\$'))).join(''),
+                    isSnippet: true,
+                }
+            }),
+        )
+    }
+
+    return
+}

typescript/src/completionsAtPosition.ts

@@ -29,6 +29,7 @@ import displayImportedInfo from './completions/displayImportedInfo'
 import changeKindToFunction from './completions/changeKindToFunction'
 import functionPropsAndMethods from './completions/functionPropsAndMethods'
 import { getTupleSignature } from './tupleSignature'
+import stringTemplateTypeCompletions from './completions/stringTemplateType'
 
 export type PrevCompletionMap = Record<
     string,
@@ -147,6 +148,13 @@ export const getCompletionsAtPosition = (
         if (newEntries?.length && ensurePrior() && prior) prior.entries = newEntries
     }
 
+    if (!prior?.entries.length) {
+        const addStringTemplateTypeCompletions = stringTemplateTypeCompletions()
+        if (addStringTemplateTypeCompletions && ensurePrior() && prior) {
+            prior.entries = [...prior.entries, ...addStringTemplateTypeCompletions]
+        }
+    }
+
     if (!prior) return
 
     if (c('tupleHelpSignature') && node) {

typescript/test/completions.spec.ts

@@ -258,6 +258,38 @@ test('Array Method Snippets', () => {
     }
 })
 
+test('String template type completions', () => {
+    const tester = fourslashLikeTester(/* ts */ `
+        const a: \`v\${'b' | 'c'}.\${number}.\${number}\` = '/*1*/';
+
+        const b: {
+            [a: \`foo_\${string}\`]: string
+        } = {
+            'foo_': '/*2*/'
+        }
+
+        const c = (p: typeof b) => { }
+
+        c({
+            '/*3*/'
+        })
+
+        b['/*4*/']
+    `)
+
+    tester.completion(1, {
+        exact: {
+            names: ['vb.|.|', 'vc.|.|'],
+        },
+    })
+
+    tester.completion([2, 3, 4], {
+        exact: {
+            names: ['foo_|'],
+        },
+    })
+})
+
 test('Switch Case Exclude Covered', () => {
     const [, _, numPositions] = fileContentsSpecialPositions(/*ts*/ `
         let test: 'foo' | 'bar'