Merge pull request #55 from zardoy/develop

Author: zardoy

src/extension.ts

@@ -2,8 +2,9 @@
 import * as vscode from 'vscode'
 import { defaultJsSupersetLangs } from '@zardoy/vscode-utils/build/langs'
 import { getActiveRegularEditor } from '@zardoy/vscode-utils'
-import { extensionCtx, getExtensionSettingId, getExtensionCommandId } from 'vscode-framework'
+import { extensionCtx, getExtensionSettingId, getExtensionCommandId, registerActiveDevelopmentCommand } from 'vscode-framework'
 import { pickObj } from '@zardoy/utils'
+import { TriggerCharacterCommand } from '../typescript/src/ipcTypes'
 import { Configuration } from './configurationType'
 import webImports from './webImports'
 import { sendCommand } from './sendCommand'
@@ -76,15 +77,22 @@ export const activateTsPlugin = (tsApi: { configurePlugin; onCompletionAccepted
         }
     })
 
+    const sharedRequest = (type: TriggerCharacterCommand, { offset, relativeOffset = 0 }: RequestOptions) => {
+        const { activeTextEditor } = vscode.window
+        if (!activeTextEditor) return
+        const { document, selection } = activeTextEditor
+        offset ??= document.offsetAt(selection.active) + relativeOffset
+        return sendCommand(type, { document, position: document.positionAt(offset) })
+    }
+
     type RequestOptions = Partial<{
         offset: number
+        relativeOffset: number
     }>
-    vscode.commands.registerCommand(getExtensionCommandId('getNodeAtPosition' as never), async ({ offset }: RequestOptions = {}) => {
-        const { activeTextEditor } = vscode.window
-        if (!activeTextEditor) return
-        const { document } = activeTextEditor
-        return sendCommand('nodeAtPosition', { document, position: offset ? document.positionAt(offset) : activeTextEditor.selection.active })
-    })
+    vscode.commands.registerCommand(getExtensionCommandId('getNodeAtPosition' as never), async (options: RequestOptions = {}) =>
+        sharedRequest('nodeAtPosition', options),
+    )
+    vscode.commands.registerCommand(getExtensionCommandId('getNodePath' as never), async (options: RequestOptions = {}) => sharedRequest('nodePath', options))
 
     if (process.env.PLATFORM === 'web') {
         const possiblySyncConfig = async () => {

typescript/src/completions/boostKeywordSuggestions.ts

@@ -1,4 +1,4 @@
-import { findChildContainingPosition } from '../utils'
+import { boostOrAddSuggestions, 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
@@ -22,8 +22,8 @@ export default (entries: ts.CompletionEntry[], position: number, node: ts.Node):
     }
     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)),
-    ]
+    return boostOrAddSuggestions(
+        entries,
+        addOrBoostKeywords.map(name => ({ name, kind: ts.ScriptElementKind.keyword })),
+    )
 }

typescript/src/completions/boostNameSuggestions.ts

@@ -0,0 +1,68 @@
+import { boostExistingSuggestions, boostOrAddSuggestions, findChildContainingPosition } from '../utils'
+
+// 1. add suggestions for unresolved indentifiers in code
+// 2. boost identifer or type name suggestion
+export default (
+    entries: ts.CompletionEntry[],
+    position: number,
+    sourceFile: ts.SourceFile,
+    node: ts.Node,
+    languageService: ts.LanguageService,
+): ts.CompletionEntry[] | undefined => {
+    // todo getPreviousPartNode() util
+    // todo object key
+    const fileText = sourceFile.getFullText()
+    const fileTextBeforePos = fileText.slice(0, position)
+    const preConstNodeOffset = fileTextBeforePos.match(/(?:const|let) ([\w\d]*)$/i)?.[1]
+    /** false - pick all identifiers after cursor
+     * node - pick identifiers that within node */
+    let filterBlock: undefined | false | ts.Node
+    if (preConstNodeOffset !== undefined) {
+        const node = findChildContainingPosition(ts, sourceFile, position - preConstNodeOffset.length - 2)
+        if (!node || !ts.isVariableDeclarationList(node)) return
+        filterBlock = false
+    } else if (ts.isIdentifier(node) && node.parent?.parent) {
+        // node > parent1 > parent2
+        let parent1 = node.parent
+        let parent2 = parent1.parent
+        if (ts.isParameter(parent1) && isFunction(parent2)) {
+            filterBlock = parent2.body ?? false
+        }
+        if (ts.isQualifiedName(parent1)) parent1 = parent1.parent
+        parent2 = parent1.parent
+        if (ts.isTypeReferenceNode(parent1) && ts.isParameter(parent2) && isFunction(parent2.parent) && ts.isIdentifier(parent2.name)) {
+            const name = parent2.name.text.replace(/^_/, '')
+            // its name convention in TS
+            const nameUpperFirst = name[0]!.toUpperCase() + name.slice(1)
+            return boostExistingSuggestions(entries, ({ name }) => {
+                if (!name.includes(nameUpperFirst)) return false
+                return true
+            })
+        }
+    }
+
+    if (filterBlock === undefined) return
+    const semanticDiagnostics = languageService.getSemanticDiagnostics(sourceFile.fileName)
+
+    const notFoundIdentifiers = semanticDiagnostics
+        .filter(({ code }) => [2552, 2304].includes(code))
+        .filter(({ start, length }) => {
+            if ([start, length].some(x => x === undefined)) return false
+            if (filterBlock === false) return start! > position
+            const diagnosticEnd = start! + length!
+            const { pos, end } = filterBlock!
+            if (start! < pos) return false
+            if (diagnosticEnd > end) return false
+            return true
+        })
+    const generalNotFoundNames = [...new Set(notFoundIdentifiers.map(({ start, length }) => fileText.slice(start!, start! + length!)))]
+    return boostOrAddSuggestions(
+        entries,
+        generalNotFoundNames.map(name => ({ name, kind: ts.ScriptElementKind.warning })),
+    )
+
+    function isFunction(node: ts.Node): node is ts.ArrowFunction | ts.FunctionDeclaration {
+        if (!node) return false
+        return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node)
+    }
+}

typescript/src/completions/isGoodPositionMethodCompletion.ts

@@ -3,7 +3,7 @@ import { GetConfig } from '../types'
 import { findChildContainingPosition, findChildContainingPositionMaxDepth } from '../utils'
 
 export const isGoodPositionBuiltinMethodCompletion = (ts: typeof tslib, sourceFile: ts.SourceFile, position: number, c: GetConfig) => {
-    const importClauseCandidate = findChildContainingPositionMaxDepth(ts, sourceFile, position, 3)
+    const importClauseCandidate = findChildContainingPositionMaxDepth(sourceFile, position, 3)
     if (importClauseCandidate && ts.isImportClause(importClauseCandidate)) return false
     const textBeforePos = sourceFile.getFullText().slice(position - 1, position)
     let currentNode = findChildContainingPosition(ts, sourceFile, textBeforePos === ':' ? position - 1 : position)

typescript/src/completionsAtPosition.ts

@@ -14,6 +14,7 @@ import objectLiteralHelpers from './completions/objectLiteralHelpers'
 import switchCaseExcludeCovered from './completions/switchCaseExcludeCovered'
 import additionalTypesSuggestions from './completions/additionalTypesSuggestions'
 import boostKeywordSuggestions from './completions/boostKeywordSuggestions'
+import boostTextSuggestions from './completions/boostNameSuggestions'
 
 export type PrevCompletionMap = Record<string, { originalName?: string; documentationOverride?: string | ts.SymbolDisplayPart[] }>
 
@@ -98,6 +99,11 @@ export const getCompletionsAtPosition = (
         prior.entries = [...prior.entries, ...addSignatureAccessCompletions]
     }
 
+    if (leftNode) {
+        const newEntries = boostTextSuggestions(prior?.entries ?? [], position, sourceFile, leftNode, languageService)
+        if (newEntries?.length && ensurePrior() && prior) prior.entries = newEntries
+    }
+
     if (!prior) return
 
     if (c('fixSuggestionsSorting')) prior.entries = fixPropertiesSorting(prior.entries, leftNode, sourceFile, program) ?? prior.entries

typescript/src/ipcTypes.ts

@@ -1,4 +1,4 @@
-export const triggerCharacterCommands = ['find-in-import', 'getPostfixes', 'nodeAtPosition', 'emmet-completions'] as const
+export const triggerCharacterCommands = ['find-in-import', 'getPostfixes', 'nodeAtPosition', 'nodePath', 'emmet-completions'] as const
 export type TriggerCharacterCommand = typeof triggerCharacterCommands[number]
 
 export type NodeAtPositionResponse = {

typescript/src/specialCommands/handle.ts

@@ -1,6 +1,6 @@
 import postfixesAtPosition from '../completions/postfixesAtPosition'
 import { NodeAtPositionResponse, TriggerCharacterCommand, triggerCharacterCommands } from '../ipcTypes'
-import { findChildContainingPosition } from '../utils'
+import { findChildContainingPosition, getNodePath } from '../utils'
 import getEmmetCompletions from './emmet'
 
 export default (
@@ -29,13 +29,14 @@ export default (
         const node = findChildContainingPosition(ts, sourceFile, position)
         return {
             entries: [],
-            typescriptEssentialsResponse: !node
-                ? undefined
-                : ({
-                      kindName: ts.SyntaxKind[node.kind],
-                      start: node.getStart(),
-                      end: node.getEnd(),
-                  } as NodeAtPositionResponse),
+            typescriptEssentialsResponse: !node ? undefined : nodeToApiResponse(node),
+        }
+    }
+    if (specialCommand === 'nodePath') {
+        const nodes = getNodePath(sourceFile, position)
+        return {
+            entries: [],
+            typescriptEssentialsResponse: nodes.map(node => nodeToApiResponse(node)),
         }
     }
     if (specialCommand === 'getPostfixes') {
@@ -47,3 +48,11 @@ export default (
         } as any
     }
 }
+
+function nodeToApiResponse(node: ts.Node): NodeAtPositionResponse {
+    return {
+        kindName: ts.SyntaxKind[node.kind]!,
+        start: node.getStart(),
+        end: node.getEnd(),
+    }
+}

typescript/src/utils.ts

@@ -1,10 +1,7 @@
 import type tslib from 'typescript/lib/tsserverlibrary'
+import { SetOptional } from 'type-fest'
 
-export function findChildContainingPosition(
-    typescript: typeof import('typescript/lib/tsserverlibrary'),
-    sourceFile: ts.SourceFile,
-    position: number,
-): ts.Node | undefined {
+export function findChildContainingPosition(typescript: typeof tslib, sourceFile: ts.SourceFile, position: number): ts.Node | undefined {
     function find(node: ts.Node): ts.Node | undefined {
         if (position >= node.getStart() && position < node.getEnd()) {
             return typescript.forEachChild(node, find) || node
@@ -15,25 +12,41 @@ export function findChildContainingPosition(
     return find(sourceFile)
 }
 
-export function findChildContainingPositionMaxDepth(
-    typescript: typeof import('typescript/lib/tsserverlibrary'),
-    sourceFile: ts.SourceFile,
-    position: number,
-    maxDepth?: number,
-): ts.Node | undefined {
+export function findChildContainingPositionMaxDepth(sourceFile: ts.SourceFile, position: number, maxDepth?: number): ts.Node | undefined {
     let currentDepth = 0
     function find(node: ts.Node): ts.Node | undefined {
         if (position >= node.getStart() && position < node.getEnd()) {
             if (++currentDepth === maxDepth) return node
-            return typescript.forEachChild(node, find) || node
+            return ts.forEachChild(node, find) || node
         }
 
         return
     }
     return find(sourceFile)
 }
 
-export const getIndentFromPos = (typescript: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile, position: number) => {
+export function getNodePath(sourceFile: ts.SourceFile, position: number): ts.Node[] {
+    const nodes: ts.Node[] = []
+    function find(node: ts.Node): ts.Node | undefined {
+        if (position >= node.getStart() && position < node.getEnd()) {
+            if (node !== sourceFile) nodes.push(node)
+            return ts.forEachChild(node, find) || node
+        }
+
+        return
+    }
+    find(sourceFile)
+    return nodes
+}
+
+// todo not impl
+type MatchStringValue = keyof typeof ts.SyntaxKind | '*'
+
+export const matchNodePath = (sourceFile: ts.SourceFile, position: number, candidates: MatchStringValue[][]) => {
+    const nodesPath = getNodePath(sourceFile, position)
+}
+
+export const getIndentFromPos = (typescript: typeof tslib, sourceFile: ts.SourceFile, position: number) => {
     const { character } = typescript.getLineAndCharacterOfPosition(sourceFile, position)
     return (
         sourceFile
@@ -63,6 +76,25 @@ export const cleanupEntryName = ({ name }: Pick<ts.CompletionEntry, 'name'>) =>
     return name.replace(/^★ /, '')
 }
 
+export const boostOrAddSuggestions = (existingEntries: ts.CompletionEntry[], topEntries: SetOptional<ts.CompletionEntry, 'sortText'>[]) => {
+    const topEntryNames = topEntries.map(({ name }) => name)
+    return [
+        ...topEntries.map(entry => ({ ...entry, sortText: entry.sortText ?? `07` })),
+        ...existingEntries.filter(({ name }) => !topEntryNames.includes(name)),
+    ]
+}
+
+export const boostExistingSuggestions = (entries: ts.CompletionEntry[], predicate: (entry: ts.CompletionEntry) => boolean | number) => {
+    return [...entries].sort((a, b) => {
+        return [a, b]
+            .map(x => {
+                const res = predicate(x)
+                return res === true ? 0 : res === false ? 1 : res
+            })
+            .reduce((a, b) => a - b)
+    })
+}
+
 // Workaround esbuild bundle modules
 export const nodeModules = __WEB__
     ? null