Merge pull request #54 from zardoy/next

feat: Exclude covered `case`s in switch for strings & enums (enabled with setting by default)

Author: zardoy

README.MD

@@ -113,16 +113,31 @@ Appends *space* to almost all keywords e.g. `const `, like WebStorm does.
 
 Patches `toString()` insert function snippet on number types to remove tabStop.
 
-### Correct Sorting
+### Enforce Properties Sorting
 
-(*enabled by default*, but doesn't work properly in new versions for now)
+(*disabled by default*) enable with `tsEssentialPlugins.fixSuggestionsSorting`
+
+Try to restore [original](https://github.com/microsoft/TypeScript/issues/49012) properties sorting in some places such as object destructure & dot property access.
+
+### Switch Exclude Covered Cases
+
+(*enabled by default*)
+
+Exclude already covered strings / enums from suggestions ([TS repo issue](https://github.com/microsoft/TypeScript/issues/13711)).
 
 ### Mark Code Actions
 
 (*enabled by default* with two settings)
 
 Mark all TS code actions with `🔵`, so you can be sure they're coming from TypeScript, and not some other extension.
 
+### Additional Types Suggestions
+
+```ts
+// Adds types in default constraint:
+type A<T extends 'foo' | 'bar' = ''> = ...
+```
+
 ### Builtin CodeFix Fixes
 
 ## Even Even More

src/configurationType.ts

@@ -234,6 +234,16 @@ export type Configuration = {
      * @default false
      */
     patchOutline: boolean
+    /**
+     * Exclude covered strings/enum cases in switch
+     * @default true
+     */
+    switchExcludeCoveredCases: boolean
+    /**
+     * Disable useless highlighting,
+     * @default disable
+     */
+    disableUselessHighlighting: 'disable' | 'inJsxArttributeStrings' | 'inAllStrings'
     /**
      * Improve JSX attribute completions:
      * - enable builtin jsx attribute completion fix

src/emmet.ts

@@ -1,18 +1,27 @@
 import * as vscode from 'vscode'
-import { getExtensionSetting, registerExtensionCommand, updateExtensionSetting } from 'vscode-framework'
+import { getExtensionSetting, registerExtensionCommand } from 'vscode-framework'
 import { EmmetResult } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
 
 export const registerEmmet = async () => {
     if (process.env.PLATFORM !== 'web') {
+        let isEmmetEnabled: boolean
+        const setIsEmmetEnabled = () => {
+            isEmmetEnabled = !!vscode.extensions.getExtension('vscode.emmet')
+        }
+
+        setIsEmmetEnabled()
+        vscode.extensions.onDidChange(setIsEmmetEnabled)
+
         const emmet = await import('@vscode/emmet-helper')
         const reactLangs = ['javascriptreact', 'typescriptreact']
         vscode.languages.registerCompletionItemProvider(
             reactLangs,
             {
                 async provideCompletionItems(document, position, token, context) {
+                    if (!getExtensionSetting('jsxEmmet')) return
                     const emmetConfig = vscode.workspace.getConfiguration('emmet')
-                    if (!emmetConfig.excludeLanguages.includes(document.languageId)) return
+                    if (isEmmetEnabled && !emmetConfig.excludeLanguages.includes(document.languageId)) return
 
                     const result = await sendCommand<EmmetResult>('emmet-completions', { document, position })
                     if (!result) return

typescript/src/completions/additionalTypesSuggestions.ts

@@ -0,0 +1,17 @@
+export default (entries: ts.CompletionEntry[], program: ts.Program, leftNode: ts.Node) => {
+    if (!ts.isStringLiteral(leftNode) || !ts.isTypeParameterDeclaration(leftNode.parent.parent) || leftNode.parent.parent.default !== leftNode.parent) return
+    const typeChecker = program.getTypeChecker()
+    const { constraint } = leftNode.parent.parent
+    if (!constraint) return
+    const type = typeChecker.getTypeAtLocation(constraint)
+    if (!(type.flags & ts.TypeFlags.Union)) return
+    const { types } = (type as any) ?? {}
+    const values: string[] = types.map(({ value }) => (typeof value === 'string' ? value : undefined)).filter(Boolean)
+    return values.map(
+        (value): ts.CompletionEntry => ({
+            name: value,
+            kind: ts.ScriptElementKind.string,
+            sortText: '',
+        }),
+    )
+}

typescript/src/completions/boostKeywordSuggestions.ts

@@ -0,0 +1,29 @@
+import { findChildContainingPosition } from '../utils'
+
+export default (entries: ts.CompletionEntry[], position: number, node: ts.Node): ts.CompletionEntry[] | undefined => {
+    // todo-not-sure for now, requires explicit completion trigger
+    const prevCharIsSpace = node.getSourceFile().getFullText()[position - 1] === ' '
+    if (!prevCharIsSpace) return
+    let extendsKeyword = ts.isInterfaceDeclaration(node) && node.end === position - 1
+    const addOrBoostKeywords = [] as string[]
+    if (!extendsKeyword) {
+        const leftNode = findChildContainingPosition(ts, node.getSourceFile(), position - 2)
+        if (leftNode && ts.isIdentifier(leftNode) && ts.isTypeParameterDeclaration(leftNode.parent)) {
+            if (!leftNode.parent.constraint) extendsKeyword = true
+        } else if (leftNode) {
+            if (ts.isBlock(leftNode)) {
+                if (ts.isTryStatement(leftNode.parent) && leftNode.parent.tryBlock === leftNode) addOrBoostKeywords.push(...['catch', 'finally'])
+                else if (ts.isCatchClause(leftNode.parent) && leftNode.parent.block === leftNode) addOrBoostKeywords.push('finally')
+            }
+            if (leftNode.kind === ts.SyntaxKind.ExportKeyword) {
+                addOrBoostKeywords.push(...['const', 'function', 'default', 'from', 'let'])
+            }
+        }
+    }
+    if (extendsKeyword) addOrBoostKeywords.push('extends')
+    if (addOrBoostKeywords.length === 0) return
+    return [
+        ...addOrBoostKeywords.map(keyword => ({ name: keyword, kind: ts.ScriptElementKind.keyword, sortText: '07' })),
+        ...entries.filter(({ name }) => !addOrBoostKeywords.includes(name)),
+    ]
+}

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,9 @@ 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'
+import additionalTypesSuggestions from './completions/additionalTypesSuggestions'
+import boostKeywordSuggestions from './completions/boostKeywordSuggestions'
 
 export type PrevCompletionMap = Record<string, { originalName?: string; documentationOverride?: string | ts.SymbolDisplayPart[] }>
 
@@ -39,6 +42,7 @@ export const getCompletionsAtPosition = (
         if (!prior) prior = { entries: [], isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false }
         return true
     }
+    const hasSuggestions = prior && prior.entries.filter(({ kind }) => kind !== ts.ScriptElementKind.warning).length !== 0
     const node = findChildContainingPosition(ts, sourceFile, position)
     /** node that is one character behind
      * useful as in most cases we work with node that is behind the cursor */
@@ -86,16 +90,18 @@ export const getCompletionsAtPosition = (
             // #endregion
         }
     }
-    const addSignatureAccessCompletions = prior?.entries.filter(({ kind }) => kind !== ts.ScriptElementKind.warning).length
-        ? []
-        : indexSignatureAccessCompletions(position, node, scriptSnapshot, sourceFile, program)
+    if (leftNode && !hasSuggestions && ensurePrior() && prior) {
+        prior.entries = additionalTypesSuggestions(prior.entries, program, leftNode) ?? prior.entries
+    }
+    const addSignatureAccessCompletions = hasSuggestions ? [] : indexSignatureAccessCompletions(position, node, scriptSnapshot, sourceFile, program)
     if (addSignatureAccessCompletions.length && ensurePrior() && prior) {
         prior.entries = [...prior.entries, ...addSignatureAccessCompletions]
     }
 
     if (!prior) return
 
     if (c('fixSuggestionsSorting')) prior.entries = fixPropertiesSorting(prior.entries, leftNode, sourceFile, program) ?? prior.entries
+    if (node) prior.entries = boostKeywordSuggestions(prior.entries, position, node) ?? prior.entries
 
     const entryNames = new Set(prior.entries.map(({ name }) => name))
     if (c('removeUselessFunctionProps.enable')) prior.entries = prior.entries.filter(e => !['Symbol', 'caller', 'prototype'].includes(e.name))
@@ -176,6 +182,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/documentHighlights.ts

@@ -0,0 +1,19 @@
+import { GetConfig } from './types'
+import { findChildContainingPosition } from './utils'
+
+export default (proxy: ts.LanguageService, languageService: ts.LanguageService, c: GetConfig) => {
+    proxy.getDocumentHighlights = (fileName, position, filesToSearch) => {
+        const prior = languageService.getDocumentHighlights(fileName, position, filesToSearch)
+        if (!prior) return
+        if (prior.length !== 1) return prior
+        const node = findChildContainingPosition(ts, languageService.getProgram()!.getSourceFile(fileName)!, position)
+        if (!node) return prior
+        if (c('disableUselessHighlighting') !== 'disable') {
+            if (ts.isStringLiteralLike(node)) {
+                if (c('disableUselessHighlighting') === 'inAllStrings') return
+                else if (ts.isJsxAttribute(node.parent)) return
+            }
+        }
+        return prior
+    }
+}

typescript/src/index.ts

@@ -17,6 +17,7 @@ import decorateCodeFixes from './codeFixes'
 import decorateReferences from './references'
 import handleSpecialCommand from './specialCommands/handle'
 import decorateDefinitions from './definitions'
+import decorateDocumentHighlights from './documentHighlights'
 
 const thisPluginMarker = Symbol('__essentialPluginsMarker__')
 
@@ -148,6 +149,7 @@ export = ({ typescript }: { typescript: typeof ts }) => {
             decorateSemanticDiagnostics(proxy, info, c)
             decorateDefinitions(proxy, info, c)
             decorateReferences(proxy, info.languageService, c)
+            decorateDocumentHighlights(proxy, info.languageService, c)
 
             if (!__WEB__) {
                 // dedicated syntax server (which is enabled by default), which fires navtree doesn't seem to receive onConfigurationChanged

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