language-service 0.0.2-preview.1

The Zena language service, which gives editors diagnostics, completions and navigation

Readme Files Dependencies Versions

language-service#

The Zena language service and Language Server Protocol (LSP) library: diagnostics, lint findings and quick fixes, hover, completions, go-to-definition, document symbols, and formatting.

Used by zena lsp (in packages/cli) and compiled to WebAssembly by @zena-lang/compiler (packages/compiler-js) for JavaScript, browser, and VS Code hosts.

Usage in Zena#

import { createLanguageService } from 'language-service';
import { LspServer } from 'language-service/server';
import { readFile } from 'zena:fs';

async function readOrNull(path: String): Future<String | null> {
  try {
    return await readFile(path);
  } catch (e) {
    return null;
  }
}

let service = createLanguageService('/stdlib', readOrNull, 'zena-component');
let diagnostics = await service.check('/workspace/main.zena', 'export let x = 42;');

Zena Libraries#

  • language-service / language-service/service — LanguageService (createLanguageService, check, lint, hover, completions, definition, documentSymbols)
  • language-service/server — LspServer JSON-RPC request/notification handler (LspServer, MessageReader, frame, offsetOf, positionOf)
  • language-service/protocol — LSP JSON serializers and error codes
  • language-service/framing — Content-Length message framing (MessageReader, frame)
  • language-service/positions — UTF-16 line/character positions to and from byte offsets (offsetOf, positionOf)
  • language-service/hover — hover type and doc-comment formatting
  • language-service/completion — identifier, member, and keyword completions
  • language-service/symbols — document symbol outline (documentSymbols, DocumentSymbol, SymbolKind)
  • language-service/compile — in-memory compilation to WebAssembly bytes (compileToWasm)
  • language-service/host — overlay CompilerHost serving open documents in place of disk files (DocumentHost)
  • language-service/analysis — per-document checked AST and scope analysis

License#

MIT

2.2 KiB Raw
/**
 * Positions as the language server protocol counts them, a line and a
 * UTF-16 offset into it, converted to and from the UTF-8 byte offsets
 * the language service works in.
 */

/** A position as the protocol counts it: a line and a UTF-16 offset. */
export type Position = {line: i32, character: i32};

let NEWLINE = 0x0A;

// The lead byte of a UTF-8 character says how many bytes it takes:
// below 0xC0 one (ASCII, or a stray continuation byte counted on its
// own), then two, three and four from these.
let TWO_BYTE_LEAD = 0xC0;
let THREE_BYTE_LEAD = 0xE0;
let FOUR_BYTE_LEAD = 0xF0;

/** How many bytes the UTF-8 character starting with `lead` takes. */
function utf8Size(lead: i32): i32 {
  if (lead < TWO_BYTE_LEAD) {
    return 1;
  }
  if (lead < THREE_BYTE_LEAD) {
    return 2;
  }
  if (lead < FOUR_BYTE_LEAD) {
    return 3;
  }
  return 4;
}

/**
 * How many UTF-16 units a UTF-8 character of `size` bytes takes: two,
 * a surrogate pair, for one outside the Basic Multilingual Plane.
 */
function utf16Width(size: i32): i32 {
  return if (size == 4) { 2 } else { 1 };
}

/** The byte offset in `source` of a protocol position. */
export function offsetOf(source: String, position: Position): i32 {
  var offset = 0;
  var line = 0;
  while (line < position.line && offset < source.length) {
    if (source.getByteAt(offset) == NEWLINE) {
      line += 1;
    }
    offset += 1;
  }
  var units = 0;
  while (units < position.character && offset < source.length) {
    let b = source.getByteAt(offset);
    if (b == NEWLINE) {
      break;
    }
    let size = utf8Size(b);
    offset += size;
    units += utf16Width(size);
  }
  return if (offset > source.length) { source.length } else { offset };
}

/** The protocol position of a byte offset in `source`. */
export function positionOf(source: String, offset: i32): Position {
  let end = if (offset < source.length) { offset } else { source.length };
  var line = 0;
  var lineStart = 0;
  for (var i = 0; i < end; i += 1) {
    if (source.getByteAt(i) == NEWLINE) {
      line += 1;
      lineStart = i + 1;
    }
  }
  var character = 0;
  var i = lineStart;
  while (i < end) {
    let size = utf8Size(source.getByteAt(i));
    character += utf16Width(size);
    i += size;
  }
  return {line: line, character: character};
}
  • compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
  • formatter formatter.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
  • lint lint.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
VersionPublishedDependenciesApproved by
0.0.2-preview.1 2026-11-19
  • compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
  • formatter formatter.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
  • lint lint.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1