@algosail/lsp 0.1.0 → 0.1.2

package/index.js

@@ -1,8 +1,47 @@
 #!/usr/bin/env node
-import { createRequire } from 'module'
-import path from 'path'
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node'
+// import { createRequire } from 'module'
+// import path from 'path'
+import {
+  createConnection,
+  ProposedFeatures,
+  TextDocumentSyncKind,
+} from 'vscode-languageserver/node'
 import { createParser } from '@algosail/parser'
 
-const connection = createConnection(ProposedFeatures.all)
+import { validateDocument } from './lib/validate.js'
+import { getCompletionItems } from './lib/completion.js'
+
 const parser = await createParser()
+
+const connection = createConnection(ProposedFeatures.all)
+
+connection.onInitialize(() => ({
+  capabilities: {
+    textDocumentSync: TextDocumentSyncKind.Full,
+    completionProvider: {
+      triggerCharacters: ['/', '#', '_', '~', '*'],
+    },
+    hoverProvider: true,
+  },
+}))
+
+connection.onDidOpenTextDocument(({ textDocument: { uri, text } }) => {
+  validateDocument(connection, parser, uri, text)
+})
+
+connection.onDidChangeTextDocument(({ textDocument: { uri }, contentChanges }) => {
+  // Full-sync mode: the last entry contains the whole new text.
+  const text = contentChanges[contentChanges.length - 1].text
+  validateDocument(connection, parser, uri, text)
+})
+
+connection.onDidCloseTextDocument(({ textDocument: { uri } }) => {
+  parser.removeAST(uri)
+  connection.sendDiagnostics({ uri, diagnostics: [] })
+})
+
+connection.onCompletion(({ textDocument: { uri } }) => {
+  return getCompletionItems(parser, uri)
+})
+
+connection.listen()

package/lib/completion.js

@@ -0,0 +1,123 @@
+import { CompletionItemKind } from 'vscode-languageserver/node'
+import { MarkupKind } from 'vscode-languageserver-types'
+import { builtinWords } from '@algosail/builtins'
+
+export function getCompletionItems(parser, uri) {
+  const items = []
+
+  for (const b of Object.values(builtinWords)) {
+    items.push({
+      label: b.name,
+      kind: CompletionItemKind.Keyword,
+      detail: `( ${b.signature} )`,
+      documentation: { kind: MarkupKind.Markdown, value: b.docs },
+    })
+  }
+
+  const ast = parser.getAST(uri)
+  if (!ast) return items
+
+  for (const [key, module] of Object.entries(ast.modules)) {
+    for (const group of module.groups) {
+      items.push({
+        label: `~${key}&${group.name}`,
+        kind: CompletionItemKind.Enum,
+        detail: `Group of tags ${group.tags.map((t) => t.name).join(', ')}`,
+        documentation: group.doc ? { kind: MarkupKind.Markdown, value: group.doc } : undefined,
+      })
+    }
+
+    for (const tag of module.tags) {
+      items.push({
+        label: `~${key}#${tag.name}`,
+        kind: CompletionItemKind.EnumMember,
+        detail: `Tag constructor in ~${key}&${tag.group}`,
+        documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
+      })
+      items.push({
+        label: `~${key}_${tag.name}`,
+        kind: CompletionItemKind.EnumMember,
+        detail: `Tag pattern in ~${key}&${tag.group}`,
+        documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
+      })
+    }
+
+    for (const map of module.maps) {
+      items.push({
+        label: `~${key}$${map.name}`,
+        kind: CompletionItemKind.Struct,
+        detail: `Map %${map.name}`,
+        documentation: map.doc ? { kind: MarkupKind.Markdown, value: map.doc } : undefined,
+      })
+      for (const field of map.fields) {
+        items.push({
+          label: `~${key}$${map.name}.${field.name}`,
+          kind: CompletionItemKind.Field,
+          detail: `Field :${field.name}${field.type ? ` (${field.type.kind})` : ''} of ~${key}$${map.name}`,
+          documentation: field.doc ? { kind: MarkupKind.Markdown, value: field.doc } : undefined,
+        })
+      }
+    }
+
+    for (const word of module.words) {
+      items.push({
+        label: `~${key}/${word.name}`,
+        kind: CompletionItemKind.Function,
+        detail: word.sig,
+        documentation: word.doc ? { kind: MarkupKind.Markdown, value: word.doc } : undefined,
+      })
+    }
+  }
+
+  for (const group of ast.groups) {
+    items.push({
+      label: `&${group.name}`,
+      kind: CompletionItemKind.Enum,
+      detail: `Group of tags ${group.tags.map((t) => t.name).join(', ')}`,
+      documentation: group.doc ? { kind: MarkupKind.Markdown, value: group.doc } : undefined,
+    })
+  }
+
+  for (const tag of ast.tags) {
+    items.push({
+      label: `#${tag.name}`,
+      kind: CompletionItemKind.EnumMember,
+      detail: `Tag constructor in &${tag.group}`,
+      documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
+    })
+    items.push({
+      label: `_${tag.name}`,
+      kind: CompletionItemKind.EnumMember,
+      detail: `Tag pattern in &${tag.group}`,
+      documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
+    })
+  }
+
+  for (const map of ast.maps) {
+    items.push({
+      label: `$${map.name}`,
+      kind: CompletionItemKind.Struct,
+      detail: `Map %${map.name}`,
+      documentation: map.doc ? { kind: MarkupKind.Markdown, value: map.doc } : undefined,
+    })
+    for (const field of map.fields) {
+      items.push({
+        label: `$${map.name}.${field.name}`,
+        kind: CompletionItemKind.Field,
+        detail: `Field :${field.name}${field.type ? ` (${field.type.kind})` : ''} of $${map.name}`,
+        documentation: field.doc ? { kind: MarkupKind.Markdown, value: field.doc } : undefined,
+      })
+    }
+  }
+
+  for (const word of ast.words) {
+    items.push({
+      label: `/${word.name}`,
+      kind: CompletionItemKind.Function,
+      detail: word.sig,
+      documentation: word.doc ? { kind: MarkupKind.Markdown, value: word.doc } : undefined,
+    })
+  }
+
+  return items
+}

package/lib/validate.js

@@ -0,0 +1,28 @@
+import { DiagnosticSeverity } from 'vscode-languageserver/node'
+
+export const validateDocument = async (connection, parser, uri, text) => {
+  try {
+    const res = await parser.parseSail(uri, text)
+
+    const diagnostics = res.errors.map((err) => ({
+      severity: DiagnosticSeverity.Error,
+      range: {
+        start: {
+          line: err.startPosition.row,
+          character: err.startPosition.column,
+        },
+        end: {
+          line: err.endPosition.row,
+          character: err.endPosition.column,
+        },
+      },
+      message: err.type === 'error' ? `Unexpected token ${err.text}` : `Missing ${err.text}`,
+      source: 'sail',
+    }))
+
+    connection.sendDiagnostics({ uri, diagnostics })
+  } catch (err) {
+    connection.console.error(`[sail-lsp] Failed to parse ${uri}: ${err.message}`)
+    connection.sendDiagnostics({ uri, diagnostics: [] })
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algosail/lsp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@algosail/builtins": "^0.0.1",
-    "@algosail/parser": "^0.0.2",
+    "@algosail/parser": "^0.0.4",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.11"
   }