fix microsoft/TypeScript#13711 for 99% cases

Author: zardoy

src/configurationType.ts

@@ -234,6 +234,11 @@ export type Configuration = {
      * @default false
      */
     patchOutline: boolean
+    /**
+     * Exclude covered strings/enum cases in switch
+     * @default true
+     */
+    switchExcludeCoveredCases: boolean
     /**
      * Improve JSX attribute completions:
      * - enable builtin jsx attribute completion fix

typescript/src/completions/switchCaseExcludeCovered.ts

@@ -0,0 +1,45 @@
+import { oneOf } from '@zardoy/utils'
+import { cleanupEntryName } from '../utils'
+
+// implementation not even ideal, but it just works for string & enums, which are used in 99% cases
+export default (entries: ts.CompletionEntry[], position: number, sourceFile: ts.SourceFile, leftNode: ts.Node) => {
+    let nodeComp = leftNode
+    let enumAccessExpr: string | null | undefined
+    if (ts.isStringLiteral(leftNode)) enumAccessExpr = null
+    else {
+        enumAccessExpr = getPropAccessExprRestText(leftNode)
+        if (!ts.isCaseClause(nodeComp.parent)) nodeComp = leftNode.parent
+    }
+    if (enumAccessExpr === undefined) return
+    let currentClause: ts.CaseClause
+    // just for type inferrence
+    const clauses = ts.isCaseClause(nodeComp.parent) && ts.isCaseBlock(nodeComp.parent.parent) ? nodeComp.parent.parent?.clauses : undefined
+    if (!clauses) return
+    currentClause = nodeComp.parent as ts.CaseClause
+    const coveredValues: string[] = []
+    for (const clause of clauses) {
+        if (ts.isDefaultClause(clause) || clause === currentClause) continue
+        const { expression } = clause
+        if (enumAccessExpr === null) {
+            if (ts.isStringLiteralLike(expression)) coveredValues.push(expression.text)
+        } else {
+            if (getPropAccessExprRestText(expression) === enumAccessExpr) {
+                coveredValues.push((expression as ts.PropertyAccessExpression).name.text)
+            }
+        }
+    }
+    return entries.filter(
+        ({ name, kind }) =>
+            !oneOf(kind, ts.ScriptElementKind.memberVariableElement, ts.ScriptElementKind.enumMemberElement, ts.ScriptElementKind.string) ||
+            !coveredValues.includes(cleanupEntryName({ name })),
+    )
+}
+
+const getPropAccessExprRestText = (node: ts.Node) => {
+    let propNode = node
+    if (ts.isPropertyAccessExpression(node.parent)) {
+        propNode = node.parent
+    }
+    if (!ts.isPropertyAccessExpression(propNode)) return
+    return propNode.getText().slice(0, propNode.name.getStart() - propNode.getStart() - 1 /* -1 for dot */)
+}

typescript/src/completionsAtPosition.ts

@@ -11,6 +11,7 @@ import improveJsxCompletions from './completions/jsxAttributes'
 import arrayMethods from './completions/arrayMethods'
 import prepareTextForEmmet from './specialCommands/prepareTextForEmmet'
 import objectLiteralHelpers from './completions/objectLiteralHelpers'
+import switchCaseExcludeCovered from './completions/switchCaseExcludeCovered'
 
 export type PrevCompletionMap = Record<string, { originalName?: string; documentationOverride?: string | ts.SymbolDisplayPart[] }>
 
@@ -176,6 +177,8 @@ export const getCompletionsAtPosition = (
         })
     }
 
+    if (leftNode && c('switchExcludeCoveredCases')) prior.entries = switchCaseExcludeCovered(prior.entries, position, sourceFile, leftNode) ?? prior.entries
+
     prior.entries = arrayMethods(prior.entries, position, sourceFile, c) ?? prior.entries
 
     if (c('improveJsxCompletions') && leftNode) prior.entries = improveJsxCompletions(prior.entries, leftNode, position, sourceFile, c('jsxCompletionsMap'))

typescript/src/utils.ts

@@ -58,6 +58,11 @@ export const getLineTextBeforePos = (sourceFile: ts.SourceFile, position: number
     return sourceFile.getFullText().slice(position - character, position)
 }
 
+export const cleanupEntryName = ({ name }: Pick<ts.CompletionEntry, 'name'>) => {
+    // intellicode highlighting
+    return name.replace(/^★ /, '')
+}
+
 // Workaround esbuild bundle modules
 export const nodeModules = __WEB__
     ? null

typescript/test/completions.spec.ts

@@ -219,6 +219,42 @@ test('Array Method Snippets', () => {
     }
 })
 
+test('Switch Case Exclude Covered', () => {
+    const [, _, numPositions] = fileContentsSpecialPositions(/*ts*/ `
+        let test: 'foo' | 'bar'
+        switch (test) {
+            case 'foo':
+                break;
+            case '/*|*/':
+                break;
+            default:
+                break;
+        }
+
+        enum SomeEnum {
+            A,
+            B
+        }
+        let test2: SomeEnum
+        switch (test2) {
+            case SomeEnum.B:
+                break;
+            case SomeEnum./*|*/:
+                break;
+            default:
+                break;
+        }
+    `)
+    const completionsByPos = {
+        1: ['bar'],
+        2: ['A'],
+    }
+    for (const [i, pos] of Object.entries(numPositions)) {
+        const { entryNames } = getCompletionsAtPosition(pos as number) ?? {}
+        expect(entryNames).toEqual(completionsByPos[i])
+    }
+})
+
 // TODO move/remove this test from here
 test('Patched navtree (outline)', () => {
     globalThis.__TS_SEVER_PATH__ = require.resolve('typescript/lib/tsserver')