@algosail/lsp 0.1.8 → 0.1.10

package/debug.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { createParser } from '@algosail/parser'
+import { readFile } from 'node:fs/promises'
+import { pathToFileURL } from 'node:url'
+import { resolve } from 'node:path'
+
+const filePath = process.argv[2]
+
+if (!filePath) {
+  console.error('Usage: node debug.js <path-to-file.sail>')
+  process.exit(1)
+}
+
+const absPath = resolve(filePath)
+const uri = pathToFileURL(absPath).href
+const text = await readFile(absPath, 'utf8')
+
+console.log(`\n=== Parsing: ${absPath} ===\n`)
+
+const parser = await createParser()
+const result = await parser.parseSail(uri, text)
+
+console.log('--- errors ---')
+if (result.errors.length === 0) {
+  console.log('(none)')
+} else {
+  for (const err of result.errors) {
+    const { row, column } = err.startPosition
+    console.log(`  [${row}:${column}] ${err.type}: ${JSON.stringify(err.text)}`)
+  }
+}
+
+console.log('\n--- groups ---')
+if (Object.keys(result.groups).length === 0) {
+  console.log('(none)')
+} else {
+  for (const [name, group] of Object.entries(result.groups)) {
+    const tags = group.tags.map((t) => t.name).join(', ')
+    console.log(`  &${name}  tags: [${tags}]  doc: ${group.doc ?? '—'}`)
+  }
+}
+
+console.log('\n--- maps ---')
+if (Object.keys(result.maps).length === 0) {
+  console.log('(none)')
+} else {
+  for (const [name, map] of Object.entries(result.maps)) {
+    const fields = map.fields.map((f) => `.${f.name}`).join(', ')
+    console.log(`  $${name}  fields: [${fields}]  doc: ${map.doc ?? '—'}`)
+  }
+}
+
+console.log('\n--- words ---')
+if (result.words.length === 0) {
+  console.log('(none)')
+} else {
+  for (const word of result.words) {
+    console.log(`  @${word.name}  sig: ${word.sig ?? '—'}`)
+  }
+}
+
+console.log('\n--- modules ---')
+if (Object.keys(result.modules).length === 0) {
+  console.log('(none)')
+} else {
+  for (const [alias, mod] of Object.entries(result.modules)) {
+    console.log(`  ~${alias}  uri: ${mod.uri}`)
+  }
+}

package/lib/completion.js

@@ -2,7 +2,18 @@ import { CompletionItemKind } from 'vscode-languageserver'
 import { MarkupKind } from 'vscode-languageserver-types'
 import { builtinWords } from '@algosail/builtins'
 
-export function getCompletionItems(connection, parser, uri) {
+function item(label, kind, detail, doc) {
+  return {
+    label,
+    insertText: label.slice(1),
+    filterText: label,
+    kind,
+    detail,
+    documentation: doc ? { kind: MarkupKind.Markdown, value: doc } : undefined,
+  }
+}
+
+export function getCompletionItems(parser, uri) {
   const items = []
 
   for (const b of Object.values(builtinWords)) {
@@ -15,110 +26,106 @@ export function getCompletionItems(connection, parser, uri) {
   }
 
   const ast = parser.getAST(uri)
-  connection.console.error(`[sail-lsp] Failed to parse ${uri}: ${ast}`)
-
   if (!ast) return items
 
   for (const [key, module] of Object.entries(ast.modules)) {
     for (const group of Object.values(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,
-      })
+      items.push(
+        item(
+          `~${key}&${group.name}`,
+          CompletionItemKind.Enum,
+          `Group of tags ${group.tags.map((t) => t.name).join(', ')}`,
+          group.doc,
+        ),
+      )
     }
 
     for (const tag of Object.values(module.tags)) {
-      items.push({
-        label: `~${key}#${tag.name}`,
-        kind: CompletionItemKind.EnumMember,
-        detail: `Tag constructor in ~${key}&${tag.group.name}`,
-        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.name}`,
-        documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
-      })
+      items.push(
+        item(
+          `~${key}#${tag.name}`,
+          CompletionItemKind.EnumMember,
+          `Tag constructor in ~${key}&${tag.group.name}`,
+          tag.doc,
+        ),
+      )
+      items.push(
+        item(
+          `~${key}_${tag.name}`,
+          CompletionItemKind.EnumMember,
+          `Tag pattern in ~${key}&${tag.group.name}`,
+          tag.doc,
+        ),
+      )
     }
 
     for (const map of Object.values(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,
-      })
+      items.push(
+        item(`~${key}$${map.name}`, CompletionItemKind.Struct, `Map $${map.name}`, map.doc),
+      )
       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,
-        })
+        items.push(
+          item(
+            `~${key}$${map.name}.${field.name}`,
+            CompletionItemKind.Field,
+            `Field .${field.name}${field.type ? ` (${field.type.kind})` : ''} of ~${key}$${map.name}`,
+            field.doc,
+          ),
+        )
       }
     }
 
     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,
-      })
+      items.push(item(`~${key}/${word.name}`, CompletionItemKind.Function, word.sig, word.doc))
     }
   }
 
   for (const group of Object.values(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,
-    })
+    items.push(
+      item(
+        `&${group.name}`,
+        CompletionItemKind.Enum,
+        `Group of tags ${group.tags.map((t) => t.name).join(', ')}`,
+        group.doc,
+      ),
+    )
   }
 
   for (const tag of Object.values(ast.tags)) {
-    items.push({
-      label: `#${tag.name}`,
-      kind: CompletionItemKind.EnumMember,
-      detail: `Tag constructor in &${tag.group.name}`,
-      documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
-    })
-    items.push({
-      label: `_${tag.name}`,
-      kind: CompletionItemKind.EnumMember,
-      detail: `Tag pattern in &${tag.group.name}`,
-      documentation: tag.doc ? { kind: MarkupKind.Markdown, value: tag.doc } : undefined,
-    })
+    items.push(
+      item(
+        `#${tag.name}`,
+        CompletionItemKind.EnumMember,
+        `Tag constructor in &${tag.group.name}`,
+        tag.doc,
+      ),
+    )
+    items.push(
+      item(
+        `_${tag.name}`,
+        CompletionItemKind.EnumMember,
+        `Tag pattern in &${tag.group.name}`,
+        tag.doc,
+      ),
+    )
   }
 
   for (const map of Object.values(ast.maps)) {
-    items.push({
-      label: `$${map.name}`,
-      kind: CompletionItemKind.Struct,
-      detail: `Map $${map.name}`,
-      documentation: map.doc ? { kind: MarkupKind.Markdown, value: map.doc } : undefined,
-    })
+    items.push(item(`$${map.name}`, CompletionItemKind.Struct, `Map $${map.name}`, map.doc))
     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,
-      })
+      items.push(
+        item(
+          `$${map.name}.${field.name}`,
+          CompletionItemKind.Field,
+          `Field .${field.name}${field.type ? ` (${field.type.kind})` : ''} of $${map.name}`,
+          field.doc,
+        ),
+      )
     }
   }
 
   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,
-    })
+    items.push(item(`/${word.name}`, CompletionItemKind.Function, word.sig, word.doc))
   }
 
   return items

package/lib/validate.js

@@ -3,7 +3,6 @@ import { DiagnosticSeverity } from 'vscode-languageserver'
 export const validateDocument = async (connection, parser, uri, text) => {
   try {
     const res = await parser.parseSail(uri, text)
-    connection.console.error(`[sail-lsp] Failed to parse ${uri}: ${res}`)
 
     const diagnostics = res.errors.map((err) => ({
       severity: DiagnosticSeverity.Error,

package/package.json

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