refactor: simplify returns in main special command handler

fix: rare TS error with incorrect special command invocations

Author: zardoy

typescript/src/decorateProxy.ts

@@ -68,7 +68,13 @@ export const decorateLanguageService = (
               )
             : undefined
         // handled specialCommand request
-        if (specialCommandResult !== undefined) return specialCommandResult as any
+        if (specialCommandResult !== null) {
+            return {
+                entries: [],
+                typescriptEssentialsResponse: specialCommandResult,
+            } as any
+        }
+
         prevCompletionsMap = {}
         const scriptSnapshot = languageServiceHost.getScriptSnapshot(fileName)
         const scriptKind = languageServiceHost.getScriptKind!(fileName)

typescript/src/specialCommands/handle.ts

@@ -27,10 +27,7 @@ export default (
     configuration: GetConfig,
     preferences: ts.UserPreferences,
     formatOptions: ts.FormatCodeSettings | undefined,
-): void | {
-    entries: []
-    typescriptEssentialsResponse: any
-} => {
+): any => {
     const _specialCommandsParts = specialCommand.split('?')
     specialCommand = _specialCommandsParts[0]! as TriggerCharacterCommand
     const specialCommandArg = _specialCommandsParts[1] && JSON.parse(_specialCommandsParts[1])
@@ -41,10 +38,7 @@ export default (
     if (specialCommand === 'emmet-completions') {
         const leftNode = findChildContainingPosition(ts, sourceFile, position - 1)
         if (!leftNode) return
-        return {
-            entries: [],
-            typescriptEssentialsResponse: getEmmetCompletions(fileName, leftNode, sourceFile, position, languageService),
-        }
+        return getEmmetCompletions(fileName, leftNode, sourceFile, position, languageService)
     }
     // todo rename from getTwoStepCodeActions to additionalCodeActions
     if (specialCommand === 'getTwoStepCodeActions') {
@@ -55,28 +49,22 @@ export default (
 
         const extendedCodeActions = getExtendedCodeActions(sourceFile, posEnd, languageService, undefined, undefined)
         return {
-            entries: [],
-            typescriptEssentialsResponse: {
-                turnArrayIntoObject: objectIntoArrayConverters(posEnd, node, undefined),
-                moveToExistingFile: moveToExistingFile ? {} : undefined,
-                extendedCodeActions: extendedCodeActions,
-            } satisfies RequestResponseTypes['getTwoStepCodeActions'],
+            turnArrayIntoObject: objectIntoArrayConverters(posEnd, node, undefined),
+            moveToExistingFile: moveToExistingFile ? {} : undefined,
+            extendedCodeActions: extendedCodeActions,
         }
     }
     if (specialCommand === 'getExtendedCodeActionEdits') {
         changeType<RequestOptionsTypes['getExtendedCodeActionEdits']>(specialCommandArg)
         const { range, applyCodeActionTitle } = specialCommandArg
         const posEnd = { pos: range[0], end: range[1] }
-        return {
-            entries: [],
-            typescriptEssentialsResponse: getExtendedCodeActions(
-                sourceFile,
-                posEnd,
-                languageService,
-                formatOptions,
-                applyCodeActionTitle,
-            ) satisfies RequestResponseTypes['getExtendedCodeActionEdits'],
-        }
+        return getExtendedCodeActions(
+            sourceFile,
+            posEnd,
+            languageService,
+            formatOptions,
+            applyCodeActionTitle,
+        ) satisfies RequestResponseTypes['getExtendedCodeActionEdits']
     }
     if (specialCommand === 'twoStepCodeActionSecondStep') {
         changeType<RequestOptionsTypes['twoStepCodeActionSecondStep']>(specialCommandArg)
@@ -105,42 +93,22 @@ export default (
                 break
             }
         }
-        return {
-            entries: [],
-            typescriptEssentialsResponse: data,
-        }
+        return data
     }
     if (specialCommand === 'getNodeAtPosition') {
         // ensure return data is the same as for node in getNodePath
         const node = findChildContainingPosition(ts, sourceFile, position)
-        return {
-            entries: [],
-            typescriptEssentialsResponse: !node ? undefined : nodeToApiResponse(node),
-        }
+        return !node ? undefined : nodeToApiResponse(node)
     }
     if (specialCommand === 'getFullMethodSnippet') {
-        return {
-            entries: [],
-            typescriptEssentialsResponse: constructMethodSnippet(
-                languageService,
-                sourceFile,
-                position,
-                configuration,
-            ) satisfies RequestResponseTypes['getFullMethodSnippet'],
-        }
+        return constructMethodSnippet(languageService, sourceFile, position, configuration) satisfies RequestResponseTypes['getFullMethodSnippet']
     }
     if (specialCommand === 'getSpanOfEnclosingComment') {
-        return {
-            entries: [],
-            typescriptEssentialsResponse: languageService.getSpanOfEnclosingComment(fileName, position, false),
-        }
+        return languageService.getSpanOfEnclosingComment(fileName, position, false)
     }
     if (specialCommand === 'getNodePath') {
         const nodes = getNodePath(sourceFile, position)
-        return {
-            entries: [],
-            typescriptEssentialsResponse: nodes.map(node => nodeToApiResponse(node)),
-        }
+        return nodes.map(node => nodeToApiResponse(node))
     }
     if (specialCommand === 'getFixAllEdits') {
         // code adopted is for asyncInSync fix for now
@@ -163,10 +131,7 @@ export default (
                 }
             }
         }
-        return {
-            entries: [],
-            typescriptEssentialsResponse: edits,
-        } as any
+        return edits
     }
     if (specialCommand === 'removeFunctionArgumentsTypesInSelection') {
         changeType<RequestOptionsTypes['removeFunctionArgumentsTypesInSelection']>(specialCommandArg)
@@ -178,15 +143,12 @@ export default (
         }
         const allParams = node.parent.parent.parameters
         return {
-            entries: [],
-            typescriptEssentialsResponse: {
-                ranges: allParams
-                    .map(param => {
-                        if (!param.type || param.name.pos > specialCommandArg.endSelection) return
-                        return [param.name.end, param.type.end]
-                    })
-                    .filter(Boolean),
-            },
+            ranges: allParams
+                .map(param => {
+                    if (!param.type || param.name.pos > specialCommandArg.endSelection) return
+                    return [param.name.end, param.type.end]
+                })
+                .filter(Boolean),
         }
     }
     if (specialCommand === 'getRangeOfSpecialValue') {
@@ -240,22 +202,16 @@ export default (
         }
         if (targetNode) {
             return {
-                entries: [],
-                typescriptEssentialsResponse: {
-                    range: Array.isArray(targetNode) ? targetNode : [targetNode.pos, targetNode.end],
-                } satisfies RequestResponseTypes['getRangeOfSpecialValue'],
-            }
+                range: Array.isArray(targetNode) ? targetNode : [targetNode.pos, targetNode.end],
+            } satisfies RequestResponseTypes['getRangeOfSpecialValue']
         } else {
             return
         }
     }
     if (specialCommand === 'acceptRenameWithParams') {
         changeType<RequestOptionsTypes['acceptRenameWithParams']>(specialCommandArg)
         overrideRequestPreferences.rename = specialCommandArg
-        return {
-            entries: [],
-            typescriptEssentialsResponse: undefined,
-        }
+        return undefined
     }
     if (specialCommand === 'pickAndInsertFunctionArguments') {
         // const sourceFile = (info.languageService as ReturnType<typeof tsFull['createLanguageService']>).getProgram()!.getSourceFile(fileName)!
@@ -270,23 +226,20 @@ export default (
         }
         sourceFile.forEachChild(collectNodes)
         return {
-            entries: [],
-            typescriptEssentialsResponse: {
-                functions: collectedNodes.map(arr => {
-                    return [
-                        arr[0],
-                        [arr[1].pos, arr[1].end],
-                        compact(
-                            arr[2].map(({ name, type }) => {
-                                // or maybe allow?
-                                if (!ts.isIdentifier(name)) return
-                                return [name.text, type?.getText() ?? '']
-                            }),
-                        ),
-                    ]
-                }),
-            } satisfies RequestResponseTypes['pickAndInsertFunctionArguments'],
-        }
+            functions: collectedNodes.map(arr => {
+                return [
+                    arr[0],
+                    [arr[1].pos, arr[1].end],
+                    compact(
+                        arr[2].map(({ name, type }) => {
+                            // or maybe allow?
+                            if (!ts.isIdentifier(name)) return
+                            return [name.text, type?.getText() ?? '']
+                        }),
+                    ),
+                ]
+            }),
+        } satisfies RequestResponseTypes['pickAndInsertFunctionArguments']
     }
     if (specialCommand === 'filterBySyntaxKind') {
         const collectedNodes: RequestResponseTypes['filterBySyntaxKind']['nodesByKind'] = {}
@@ -305,12 +258,11 @@ export default (
         }
         sourceFile.forEachChild(collectNodes)
         return {
-            entries: [],
-            typescriptEssentialsResponse: {
-                nodesByKind: collectedNodes,
-            } satisfies RequestResponseTypes['filterBySyntaxKind'],
-        }
+            nodesByKind: collectedNodes,
+        } satisfies RequestResponseTypes['filterBySyntaxKind']
     }
+
+    return null
 }
 
 function changeType<T>(arg): asserts arg is T {}