coc-vscode-loader 1.1.1 → 1.1.4

package/converter/src/scanner.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface ScanResult {
+  files: ScannedFile[]
+  hasTsBridge: boolean
+  hasDecoration: boolean
+  hasWebview: boolean
+  summary: string
+}
+
+export interface ScannedFile {
+  path: string
+  apis: string[]
+  actions: string[]
+}
+
+const UNSUPPORTED_PATTERNS = [
+  { pattern: 'createTextEditorDecorationType', action: 'mark-unsupported', label: 'decoration API' },
+  { pattern: 'setDecorations', action: 'mark-unsupported', label: 'decoration API' },
+  { pattern: 'createWebviewPanel', action: 'mark-unsupported', label: 'webview API' },
+  { pattern: 'registerTreeDataProvider', action: 'mark-unsupported', label: 'tree data provider' },
+  { pattern: 'window.showInputBox', action: 'needs-rewrite', label: 'use requestInput instead' },
+  { pattern: 'env.openExternal', action: 'mark-unsupported', label: 'no equivalent' },
+  { pattern: 'showOpenDialog', action: 'mark-unsupported', label: 'no equivalent' },
+  { pattern: 'showSaveDialog', action: 'mark-unsupported', label: 'no equivalent' },
+]
+
+const TS_BRIDGE_PATTERNS = [
+  'tsserver/request',
+  'tsserver/response',
+  '_vue:',
+  'typescript.tsserverRequest',
+]
+
+export function scan(dir: string): ScanResult {
+  const files: ScannedFile[] = []
+  let hasTsBridge = false
+  let hasDecoration = false
+  let hasWebview = false
+
+  const tsFiles = walk(dir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+
+  for (const filePath of tsFiles) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const apis: string[] = []
+    const actions: string[] = []
+    const relative = path.relative(dir, filePath)
+
+    // Check for vscode imports
+    if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
+      apis.push('vscode')
+    }
+
+    // Check for unsupported patterns
+    for (const { pattern, action, label } of UNSUPPORTED_PATTERNS) {
+      if (content.includes(pattern)) {
+        apis.push(label)
+        actions.push(action)
+        if (action === 'mark-unsupported') {
+          if (label.includes('decoration')) hasDecoration = true
+          if (label.includes('webview')) hasWebview = true
+        }
+      }
+    }
+
+    // Check for TS bridge
+    for (const pattern of TS_BRIDGE_PATTERNS) {
+      if (content.includes(pattern)) {
+        hasTsBridge = true
+        apis.push('tsserver bridge')
+        break
+      }
+    }
+
+    // Check for LanguageClient
+    if (content.includes('LanguageClient')) {
+      apis.push('LanguageClient')
+    }
+
+    // Check for typescriptServerPlugins in package.json
+    if (relative === 'package.json' || filePath.endsWith('package.json')) {
+      if (content.includes('typescriptServerPlugins')) {
+        hasTsBridge = true
+        apis.push('typescriptServerPlugins')
+      }
+    }
+
+    if (apis.length > 0) {
+      files.push({ path: relative, apis, actions })
+    }
+  }
+
+  // Read package.json
+  const pkgPath = path.join(dir, 'package.json')
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    const apis: string[] = []
+    if (pkg.contributes?.typescriptServerPlugins) {
+      hasTsBridge = true
+      apis.push('typescriptServerPlugins')
+    }
+    if (pkg.activationEvents) {
+      apis.push(`activationEvents: ${pkg.activationEvents.length}`)
+    }
+    if (apis.length > 0) {
+      files.push({ path: 'package.json', apis, actions: [] })
+    }
+  }
+
+  return {
+    files,
+    hasTsBridge,
+    hasDecoration,
+    hasWebview,
+    summary: [
+      `found ${files.length} files with vscode API`,
+      hasTsBridge ? ', ts-bridge detected' : '',
+      hasDecoration ? ', decoration API (marked)' : '',
+      hasWebview ? ', webview API (marked)' : '',
+    ].join(''),
+  }
+}
+
+function walk(dir: string): string[] {
+  const files: string[] = []
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name)
+    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+      files.push(...walk(p))
+    } else if (entry.isFile()) {
+      files.push(p)
+    }
+  }
+  return files
+}

package/converter/src/transforms/class-to-factory.ts

@@ -0,0 +1,54 @@
+import { Transform } from '../types.js'
+import { SyntaxKind } from 'ts-morph'
+
+const FACTORY_TYPES = new Set([
+  'Position', 'Range', 'Location', 'LocationLink',
+  'Diagnostic', 'DiagnosticRelatedInformation',
+  'TextEdit',
+  'Hover', 'CompletionItem', 'CompletionList',
+  'CodeAction', 'CodeLens', 'DocumentLink',
+  'Color', 'ColorInformation', 'ColorPresentation',
+  'FoldingRange', 'SelectionRange',
+  'DocumentHighlight', 'SymbolInformation', 'DocumentSymbol',
+  'ParameterInformation', 'SignatureInformation',
+  'CallHierarchyItem', 'CallHierarchyIncomingCall', 'CallHierarchyOutgoingCall',
+  'TypeHierarchyItem', 'LinkedEditingRanges',
+])
+
+export const transformClassToFactory: Transform = (ctx) => {
+  const { file } = ctx
+
+  // AST approach: try to replace via ts-morph
+  const nodes = file.getDescendantsOfKind(SyntaxKind.NewExpression)
+  const astReplacements: Array<{ node: any, text: string }> = []
+  for (const expr of nodes) {
+    const text = expr.getText()
+    const m = text.match(/^new\s+(\w+)\(/)
+    if (!m || !FACTORY_TYPES.has(m[1])) continue
+    const args = text.slice(m[0].length, -1)
+    astReplacements.push({ node: expr, text: `${m[1]}.create(${args})` })
+  }
+  for (const { node, text } of astReplacements) {
+    try { node.replaceWithText(text) } catch {}
+  }
+
+  // Text fallback: catch remaining new Xxx() that AST might have missed
+  let text = file.getText()
+  text = text.replace(
+    /\bnew\s+(Position|Range|Location|Diagnostic|TextEdit)\s*\(/g,
+    (match, type) => `${type}.create(`
+  )
+
+  // CompletionItem.create(label) doesn't accept kind in coc.
+  // Convert `CompletionItem.create(label, kind)` to `item = CompletionItem.create(label); item.kind = kind`
+  text = text.replace(
+    /const\s+(\w+)\s*=\s*CompletionItem\.create\(([^,]+),\s*([^)]+)\)/g,
+    (_, varName, label, kind) => {
+      return `const ${varName} = CompletionItem.create(${label}); ${varName}.kind = ${kind}`
+    }
+  )
+
+  if (text !== file.getText()) {
+    file.replaceWithText(text)
+  }
+}

package/converter/src/transforms/enum-offset.ts

@@ -0,0 +1,49 @@
+import { Transform } from '../types.js'
+
+/**
+ * Handle enum value offsets between VS Code (0-based) and coc (1-based LSP).
+ * Some enums like DiagnosticSeverity, CompletionItemKind, SymbolKind have
+ * different numeric values, but since coc re-exports them with correct values,
+ * symbol references (like CompletionItemKind.Value) work correctly at runtime.
+ *
+ * This transform handles cases where hardcoded numbers are used instead of
+ * enum symbols, which is rare but can happen in extensions.
+ *
+ * Affected enums and their offset:
+ *   CompletionItemKind:      vscode Text=0 → coc Text:1  (differs by 1 for first ~11 values)
+ *   SymbolKind:              vscode File=0 → coc File:1
+ *   DocumentHighlightKind:   vscode Text=0 → coc Text:1
+ *   DiagnosticSeverity:      vscode Error=0 → coc Error:1
+ */
+export const transformEnumOffset: Transform = (ctx) => {
+  const { file } = ctx
+  let content = file.getText()
+
+  // Detect hardcoded numbers used in enum position (e.g., CompletionItemKind.Xxx).
+  // This is hard to detect perfectly, so we log a note when numeric literals
+  // appear near enum-type names.
+  const enumPatterns = [
+    'CompletionItemKind', 'SymbolKind', 'DocumentHighlightKind', 'DiagnosticSeverity',
+    'CompletionTriggerKind', 'InlineCompletionTriggerKind',
+  ]
+
+  for (const enumName of enumPatterns) {
+    // Check if the enum is imported/used with a hardcoded number nearby
+    const enumRefs = content.match(new RegExp(`${enumName}\\.\\w+`, 'g'))
+    if (enumRefs) {
+      // Symbol references are fine - they resolve at runtime
+      // Only note if there are raw numbers being compared
+    }
+  }
+
+  // Replace any numeric enum comparisons with comments
+  // e.g., `severity === 0` → `severity === 0 /* DiagnosticSeverity.Error = 1 in coc */`
+  content = content.replace(
+    /(severity\s*[=!]==?\s*)(\d+)/g,
+    '$1$2 /* DiagnosticSeverity values differ in coc (1-4 vs 0-3) */'
+  )
+
+  if (content !== file.getText()) {
+    file.replaceWithText(content)
+  }
+}

package/converter/src/transforms/import-mapping.ts

@@ -0,0 +1,47 @@
+import { Transform } from '../types.js'
+
+/**
+ * Replace `from 'vscode'` with `from 'coc.nvim'`,
+ * and apply name remapping for known API differences.
+ */
+const MAPPINGS: Record<string, string> = {
+  // namespace
+  'vscode': 'coc.nvim',
+
+  // naming differences
+  'EventEmitter': 'Emitter',
+  'Disposable': 'Disposable',
+
+  // function/method renames
+  'getExtension': 'getExtensionById',
+  'registerReferenceProvider': 'registerReferencesProvider',
+  'registerCodeActionsProvider': 'registerCodeActionProvider',
+  'registerColorProvider': 'registerDocumentColorProvider',
+  'registerDocumentFormattingEditProvider': 'registerDocumentFormatProvider',
+  'registerDocumentRangeFormattingEditProvider': 'registerDocumentRangeFormatProvider',
+}
+
+export const transformImportMapping: Transform = (ctx) => {
+  const { file } = ctx
+
+  // Rewrite import declarations
+  file.getImportDeclarations().forEach(decl => {
+    const mod = decl.getModuleSpecifierValue()
+    if (mod === 'vscode') {
+      decl.setModuleSpecifier('coc.nvim')
+    }
+  })
+
+  // Rewrite named references
+  file.getDescendantsOfKind(192 /* Identifier */).forEach(node => {
+    const text = node.getText()
+    const mapped = MAPPINGS[text]
+    if (mapped && mapped !== text) {
+      // Only replace if it's a direct reference, not part of a string
+      const parent = node.getParent()
+      if (parent && parent.getKindName() !== 'StringLiteral') {
+        node.replaceWithText(mapped)
+      }
+    }
+  })
+}

package/converter/src/transforms/language-client.ts

@@ -0,0 +1,48 @@
+import { Transform } from '../types.js'
+
+/**
+ * Adapt LanguageClient construction from VS Code style to coc style.
+ *
+ * VS Code:
+ *   new LanguageClient('id', 'name', serverOptions, clientOptions)
+ *   serverOptions = { run: { module, transport }, debug: { module, transport } }
+ *
+ * coc:
+ *   new LanguageClient('id', 'name', serverOptions, clientOptions)
+ *   serverOptions = { module, transport, options? }
+ */
+export const transformLanguageClient: Transform = (ctx) => {
+  const { file } = ctx
+
+  file.getDescendantsOfKind(199 /* CallExpression */).forEach(call => {
+    const text = call.getText()
+
+    // Match: new LanguageClient(...)
+    if (!text.startsWith('new LanguageClient(')) return
+
+    // Extract serverOptions argument (3rd positional arg)
+    const args = call.getArguments()
+    if (args.length < 3) return
+
+    const serverOpts = args[2].getText()
+
+    // Check if it has the VS Code style { run, debug } structure
+    if (!serverOpts.includes('run:') || !serverOpts.includes('debug:')) return
+
+    // Extract module and transport from run block
+    const moduleMatch = serverOpts.match(/module:\s*(\S+)/)
+    const transportMatch = serverOpts.match(/transport:\s*(\S+)/)
+
+    if (!moduleMatch) return
+
+    // Build coc-style serverOptions
+    let cocOpts = `{\n      module: ${moduleMatch[1]}`
+    if (transportMatch) {
+      cocOpts += `,\n      transport: ${transportMatch[1]}`
+    }
+    cocOpts += '\n    }'
+
+    // Replace the argument
+    args[2].replaceWithText(cocOpts)
+  })
+}

package/converter/src/transforms/provider-register.ts

@@ -0,0 +1,55 @@
+import { Transform } from '../types.js'
+
+/**
+ * Adapt provider registration function signatures.
+ *
+ * registerCompletionItemProvider(sel, p, t) → registerCompletionItemProvider('name', 'sc', sel, p, [t])
+ * registerCodeActionsProvider(sel, p, m?)   → registerCodeActionProvider(sel, p, clientId?, kinds?)
+ * registerReferenceProvider(sel, p)         → registerReferencesProvider(sel, p)
+ * registerDocumentFormattingEditProvider    → registerDocumentFormatProvider(sel, p, priority?)
+ * registerColorProvider                     → registerDocumentColorProvider(sel, p)
+ */
+const RENAMES: Record<string, string> = {
+  registerCodeActionsProvider: 'registerCodeActionProvider',
+  registerReferenceProvider: 'registerReferencesProvider',
+  registerDocumentFormattingEditProvider: 'registerDocumentFormatProvider',
+  registerDocumentRangeFormattingEditProvider: 'registerDocumentRangeFormatProvider',
+  registerColorProvider: 'registerDocumentColorProvider',
+}
+
+export const transformProviderRegister: Transform = (ctx) => {
+  let { file } = ctx
+  let content = file.getText()
+  let changed = false
+
+  // 1. Simple renames
+  for (const [from, to] of Object.entries(RENAMES)) {
+    const re = new RegExp(`\\b${from}\\b`, 'g')
+    if (re.test(content)) {
+      content = content.replace(re, to)
+      changed = true
+    }
+  }
+
+  // 2. registerCompletionItemProvider: insert name + shortcut at beginning
+  if (content.includes('registerCompletionItemProvider')) {
+    content = content.replace(
+      /registerCompletionItemProvider\(/g,
+      `registerCompletionItemProvider('plugin', 'PL', `
+    )
+    // Wrap the last argument in an array if it's a string (trigger chars)
+    content = content.replace(
+      /(registerCompletionItemProvider\([^)]+),\s*'([^']+)'\)/g,
+      '$1, ["$2"])'
+    )
+    content = content.replace(
+      /(registerCompletionItemProvider\([^)]+),\s*"([^"]+)"\)/g,
+      '$1, ["$2"])'
+    )
+    changed = true
+  }
+
+  if (changed) {
+    file.replaceWithText(content)
+  }
+}

package/converter/src/types.ts

@@ -0,0 +1,8 @@
+import { Project, SourceFile } from 'ts-morph'
+
+export interface TransformContext {
+  file: SourceFile
+  project: Project
+}
+
+export type Transform = (ctx: TransformContext) => void