feat: object literal completions for just true or false types

zardoy · zardoy · commit c92d568e1457 · 2023-04-05T20:35:30.000+03:00
fix(object-literal-completions): use symbol completion knowledge. In other words starting from TS 5 now object literal completions should work in absolutely any location for any supported completion
diff --git a/typescript/src/completions/objectLiteralCompletions.ts b/typescript/src/completions/objectLiteralCompletions.ts
@@ -1,5 +1,5 @@
 import { GetConfig } from '../types'
-import { getFullTypeChecker } from '../utils'
+import { getFullTypeChecker, isTs5 } from '../utils'
 import { sharedCompletionContext } from './sharedContext'
 
 export default (
@@ -24,12 +24,20 @@ export default (
         entries = [...entries]
         const typeChecker = languageService.getProgram()!.getTypeChecker()!
         const objType = typeChecker.getContextualType(node)
-        if (!objType) return
-        const properties = getAllPropertiesOfType(objType, typeChecker)
-        for (const property of properties) {
-            const entry = entries.find(({ name }) => name === property.name)
-            if (!entry) continue
-            const type = typeChecker.getTypeOfSymbolAtLocation(property, node)
+        let oldProperties: ts.Symbol[] | undefined
+        if (!isTs5()) {
+            if (!objType) return
+            oldProperties = getAllPropertiesOfType(objType, typeChecker)
+        }
+        for (const entry of entries) {
+            let type: ts.Type | undefined
+            if (!isTs5()) {
+                const property = oldProperties!.find(property => property.name === entry.name)
+                if (!property) continue
+                type = typeChecker.getTypeOfSymbolAtLocation(property, node)
+            } else if (entry.symbol) {
+                type = typeChecker.getTypeOfSymbol(entry.symbol)
+            }
             if (!type) continue
             if (isFunctionType(type, typeChecker)) {
                 if (['above', 'remove'].includes(keepOriginal) && preferences.includeCompletionsWithObjectLiteralMethodSnippets) {
@@ -52,14 +60,16 @@ export default (
                 return [`: ${quote}$1${quote},$0`, `: ${quote}${quote},`]
             }
             const insertObjectArrayInnerText = c('objectLiteralCompletions.insertNewLine') ? '\n\t$1\n' : '$1'
+            const booleanCompletion = getBooleanCompletion(type, typeChecker)
             const completingStyleMap = [
                 [getQuotedSnippet, isStringCompletion],
-                [[': ${1|true,false|},$0', `: true/false,`], isBooleanCompletion],
+                [[`: ${booleanCompletion?.[0] ?? ''},`, `: ${booleanCompletion?.[0] ?? ''}`], () => booleanCompletion?.length === 1],
+                [[': ${1|true,false|},$0', `: true/false,`], () => booleanCompletion?.length === 2],
                 [[`: [${insertObjectArrayInnerText}],$0`, `: [],`], isArrayCompletion],
                 [[`: {${insertObjectArrayInnerText}},$0`, `: {},`], isObjectCompletion],
             ] as const
             const fallbackSnippet = c('objectLiteralCompletions.fallbackVariant') ? ([': $0,', ': ,'] as const) : undefined
-            const insertSnippetVariant = completingStyleMap.find(([, detector]) => detector(type, typeChecker))?.[0] ?? fallbackSnippet
+            const insertSnippetVariant = completingStyleMap.find(([, detector]) => detector(type!, typeChecker))?.[0] ?? fallbackSnippet
             if (!insertSnippetVariant) continue
             const [insertSnippetText, insertSnippetPreview] = typeof insertSnippetVariant === 'function' ? insertSnippetVariant() : insertSnippetVariant
             const insertText = entry.name + insertSnippetText
@@ -104,31 +114,36 @@ const isStringCompletion = (type: ts.Type) => {
     return false
 }
 
-const isBooleanCompletion = (type: ts.Type, checker: ts.TypeChecker) => {
-    if (type.flags & ts.TypeFlags.Undefined) return false
+const getBooleanCompletion = (type: ts.Type, checker: ts.TypeChecker) => {
+    if (type.flags & ts.TypeFlags.Undefined) return
     // todo support boolean literals (boolean like)
-    if (type.flags & ts.TypeFlags.Boolean) return true
     const trueType = getFullTypeChecker(checker).getTrueType() as any
     const falseType = getFullTypeChecker(checker).getFalseType() as any
-    let seenTrueType = false
-    let seenFalseType = false
-    if (type.isUnion()) {
-        const match = isEverySubtype(type, type => {
-            if (type.flags & ts.TypeFlags.Boolean) return true
-            if (type === trueType) {
-                seenTrueType = true
-                return true
-            }
-            if (type === falseType) {
-                seenFalseType = true
-                return true
-            }
-            return false
-        })
-        if (seenFalseType !== seenTrueType) return false
-        return match
+    const seenTypes = new Set<string>()
+    if (type.flags & ts.TypeFlags.Boolean) {
+        seenTypes.add('true')
+        seenTypes.add('false')
     }
-    return false
+    const match = isEverySubtype({ types: type.isUnion() ? type.types : [type] } as any, type => {
+        if (type.flags & ts.TypeFlags.Boolean) {
+            seenTypes.add('true')
+            seenTypes.add('false')
+            return true
+        }
+        if (type === trueType) {
+            seenTypes.add('true')
+            return true
+        }
+        if (type === falseType) {
+            seenTypes.add('false')
+            return true
+        }
+        return false
+    })
+    if (!match) return
+
+    if (seenTypes.size === 0) return
+    return [...seenTypes.keys()]
 }
 
 const isArrayCompletion = (type: ts.Type, checker: ts.TypeChecker) => {
diff --git a/typescript/src/constructMethodSnippet.ts b/typescript/src/constructMethodSnippet.ts
@@ -8,7 +8,7 @@ export default (
     languageService: ts.LanguageService,
     sourceFile: ts.SourceFile,
     position: number,
-    symbol: ts.Symbol,
+    symbol: ts.Symbol | /*for easier testing*/ undefined,
     c: GetConfig,
     // acceptAmbiguous: boolean,
     resolveData: {
@@ -19,7 +19,7 @@ export default (
     if (!containerNode || isTypeNode(containerNode)) return
 
     const checker = languageService.getProgram()!.getTypeChecker()!
-    const type = checker.getTypeOfSymbol(symbol)
+    const type = symbol ? checker.getTypeOfSymbol(symbol) : checker.getTypeAtLocation(containerNode)
 
     if (ts.isIdentifier(containerNode)) containerNode = containerNode.parent
     if (ts.isPropertyAccessExpression(containerNode)) containerNode = containerNode.parent
diff --git a/typescript/test/completions.spec.ts b/typescript/test/completions.spec.ts
@@ -109,9 +109,12 @@ test('Function props: cleans & highlights', () => {
 const compareMethodSnippetAgainstMarker = (inputMarkers: number[], marker: number, expected: string | null | string[]) => {
     const obj = Object.fromEntries(inputMarkers.entries())
     const markerPos = obj[marker]!
-    const methodSnippet = constructMethodSnippet(languageService, getSourceFile(), markerPos, defaultConfigFunc, false)
-    if (methodSnippet === 'ambiguous') {
-        expect(methodSnippet).toEqual(expected)
+    const resolvedData = {
+        isAmbiguous: false,
+    }
+    const methodSnippet = constructMethodSnippet(languageService, getSourceFile(), markerPos, undefined, defaultConfigFunc, resolvedData)
+    if (resolvedData.isAmbiguous) {
+        expect('ambiguous').toEqual(expected)
         return
     }
     const snippetToInsert = methodSnippet ? `(${methodSnippet.join(', ')})` : null
@@ -531,13 +534,15 @@ test('Additional types suggestions', () => {
     })
 })
 
-test('Object Literal Completions', () => {
+test.only('Object Literal Completions', () => {
     const [_positivePositions, _negativePositions, numPositions] = fileContentsSpecialPositions(/* ts */ `
     interface Options {
         usedOption
         mood?: 'happy' | 'sad'
         callback?()
         additionalOptions?: {
+            bar: boolean
+            bar2: false
             foo?: boolean
         }
         plugins: Array<{ name: string, setup(build) }>
@@ -551,11 +556,18 @@ test('Object Literal Completions', () => {
     })
 
     const somethingWithUntions: { a: string } | { a: any[], b: string } = {/*2*/}
+
+    makeDay({
+        additionalOptions: {
+            /*3*/
+        }
+    })
     `)
     const { entriesSorted: pos1 } = getCompletionsAtPosition(numPositions[1]!)!
     const { entriesSorted: pos2 } = getCompletionsAtPosition(numPositions[2]!)!
+    const { entriesSorted: pos3 } = getCompletionsAtPosition(numPositions[3]!)!
     // todo resolve sorting problem + add tests with other keepOriginal (it was tested manually)
-    for (const entry of [...pos1, ...pos2]) {
+    for (const entry of [...pos1, ...pos2, ...pos3]) {
         entry.insertText = entry.insertText?.replaceAll('\n', '\\n')
     }
     expect(pos1).toMatchInlineSnapshot(/* json */ `
@@ -634,6 +646,16 @@ test('Object Literal Completions', () => {
         "b: \\"$1\\",$0",
       ]
     `)
+    expect(pos3.map(x => x.insertText)).toMatchInlineSnapshot(`
+      [
+        "bar",
+        "bar: \${1|true,false|},$0",
+        "bar2",
+        "bar2: false,",
+        "foo",
+        "foo: \${1|true,false|},$0",
+      ]
+    `)
 })
 
 test('Extract to type / interface name inference', () => {
