@staticbolt/lsp 1.0.0-beta.30 → 1.0.0-beta.32

package/src/helpers/syntax-tokens.ts

@@ -0,0 +1,327 @@
+import { SemanticTokenModifiers, SemanticTokenTypes } from "vscode-languageserver-protocol";
+
+import type * as ts from "typescript";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+
+/** A token with the names of its type and modifiers. */
+export interface SyntaxToken {
+  /** The zero-based line the token is on. */
+  line: number;
+
+  /** The zero-based character the token starts at. */
+  character: number;
+
+  /** The number of characters the token spans. */
+  length: number;
+
+  /** The name of the token type. */
+  type: string;
+
+  /** The names of the token modifiers. */
+  modifiers: readonly string[];
+}
+
+/** A standard token type with modifiers, what an editor that knows only the standard types is sent for a scoped type. */
+interface StandardType {
+  /** The standard type. */
+  type: string;
+
+  /** Its modifiers. */
+  modifiers: readonly string[];
+}
+
+/** A member name, as TypeScript names the ones it knows. */
+const PROPERTY: StandardType = { type: SemanticTokenTypes.property, modifiers: [] };
+
+/** The literals of the language as the standard types see them: read-only variables of the library. */
+const LITERAL: StandardType = {
+  type: SemanticTokenTypes.variable,
+  modifiers: [SemanticTokenModifiers.readonly, SemanticTokenModifiers.defaultLibrary],
+};
+
+/**
+ * The token types of what TypeScript's own tokens leave out, after the grammar scopes a TypeScript file gets them coloured by, so
+ * an editor that maps them to those scopes colours the code as it colours TypeScript. Split where themes tell the scopes apart: a
+ * `const` sits in `meta.var.expr`, a `class` in `meta.class`, an `import` in `meta.import`. The values are the standard types an
+ * editor that knows only those is sent instead.
+ */
+export const SCOPED_TYPES = {
+  /** `if`, `return`, `await`: `keyword.control`. */
+  keywordControl: { type: SemanticTokenTypes.keyword, modifiers: [] },
+
+  /** `import`, `export`, `from`, `as`: `meta.import keyword.control.import`. */
+  keywordControlImport: { type: SemanticTokenTypes.keyword, modifiers: [] },
+
+  /** `const`, `let`, `var`: `meta.var.expr storage.type`. */
+  storageTypeVariable: { type: SemanticTokenTypes.modifier, modifiers: [] },
+
+  /** `function`: `meta.function storage.type.function`. */
+  storageTypeFunction: { type: SemanticTokenTypes.modifier, modifiers: [] },
+
+  /** `class`: `meta.class storage.type.class`. */
+  storageTypeClass: { type: SemanticTokenTypes.modifier, modifiers: [] },
+
+  /** `interface`, `type`, `enum`, `namespace`: `storage.type`. */
+  storageType: { type: SemanticTokenTypes.modifier, modifiers: [] },
+
+  /** `async`, `static`, `readonly`, `extends`: `storage.modifier`. */
+  storageModifier: { type: SemanticTokenTypes.modifier, modifiers: [] },
+
+  /** `typeof`, `instanceof`, `in`: `keyword.operator.expression`. */
+  keywordOperatorExpression: { type: SemanticTokenTypes.keyword, modifiers: [] },
+
+  /** `new`: `new.expr keyword.operator.new`. */
+  keywordOperatorNew: { type: SemanticTokenTypes.keyword, modifiers: [] },
+
+  /** `true`, `null`, `undefined`: `constant.language`. */
+  constantLanguage: LITERAL,
+
+  /** `this`, `super`: `variable.language`. */
+  variableLanguage: LITERAL,
+
+  /** `string`, `number`, `boolean`: `meta.type.annotation support.type.primitive`. */
+  supportTypePrimitive: { type: SemanticTokenTypes.type, modifiers: [SemanticTokenModifiers.defaultLibrary] },
+} as const satisfies Record<string, StandardType>;
+
+/** A scoped token type. */
+type ScopedType = keyof typeof SCOPED_TYPES;
+
+/** The scoped type of each keyword TypeScript tokenizes as one; the control flow keywords are the rest. */
+type Keywords = Partial<Record<ts.SyntaxKind, ScopedType>>;
+
+/** Names the tokens of a parsed TypeScript text. */
+export type SyntaxTokenizer = (sourceFile: ts.SourceFile, document: TextDocument, checker?: ts.TypeChecker) => SyntaxToken[];
+
+/** The punctuation that is an operator; the brackets, separators and accessors are left to the default colour. */
+const OPERATORS = new Set(
+  (
+    "= == === != !== + - * / % ** ++ -- < > <= >= && || ?? ! ~ & | ^ << >> >>> ? : => ... += -= *= /= %= **= <<= >>= >>>= " +
+    "&= |= ^= &&= ||= ??="
+  ).split(" ")
+);
+
+/** The keyword table, with the `SyntaxKind` values of the TypeScript in use. */
+function keywordsOf(typescript: typeof ts): Keywords {
+  const { SyntaxKind } = typescript;
+  const keywords: Keywords = {};
+
+  const table: [ts.SyntaxKind[], ScopedType][] = [
+    [[SyntaxKind.ImportKeyword, SyntaxKind.ExportKeyword, SyntaxKind.FromKeyword, SyntaxKind.AsKeyword], "keywordControlImport"],
+    [[SyntaxKind.ConstKeyword, SyntaxKind.LetKeyword, SyntaxKind.VarKeyword], "storageTypeVariable"],
+    [[SyntaxKind.FunctionKeyword], "storageTypeFunction"],
+    [[SyntaxKind.ClassKeyword], "storageTypeClass"],
+    [
+      [
+        SyntaxKind.InterfaceKeyword,
+        SyntaxKind.TypeKeyword,
+        SyntaxKind.EnumKeyword,
+        SyntaxKind.NamespaceKeyword,
+        SyntaxKind.ModuleKeyword,
+      ],
+      "storageType",
+    ],
+    [
+      [
+        SyntaxKind.AbstractKeyword,
+        SyntaxKind.AccessorKeyword,
+        SyntaxKind.AsyncKeyword,
+        SyntaxKind.DeclareKeyword,
+        SyntaxKind.ExtendsKeyword,
+        SyntaxKind.ImplementsKeyword,
+        SyntaxKind.OverrideKeyword,
+        SyntaxKind.PrivateKeyword,
+        SyntaxKind.ProtectedKeyword,
+        SyntaxKind.PublicKeyword,
+        SyntaxKind.ReadonlyKeyword,
+        SyntaxKind.StaticKeyword,
+      ],
+      "storageModifier",
+    ],
+    [
+      [
+        SyntaxKind.DeleteKeyword,
+        SyntaxKind.InKeyword,
+        SyntaxKind.InferKeyword,
+        SyntaxKind.InstanceOfKeyword,
+        SyntaxKind.IsKeyword,
+        SyntaxKind.KeyOfKeyword,
+        SyntaxKind.OfKeyword,
+        SyntaxKind.SatisfiesKeyword,
+        SyntaxKind.TypeOfKeyword,
+      ],
+      "keywordOperatorExpression",
+    ],
+    [[SyntaxKind.NewKeyword], "keywordOperatorNew"],
+    [[SyntaxKind.TrueKeyword, SyntaxKind.FalseKeyword, SyntaxKind.NullKeyword], "constantLanguage"],
+    [[SyntaxKind.ThisKeyword, SyntaxKind.SuperKeyword], "variableLanguage"],
+    [
+      [
+        SyntaxKind.AnyKeyword,
+        SyntaxKind.BigIntKeyword,
+        SyntaxKind.BooleanKeyword,
+        SyntaxKind.NeverKeyword,
+        SyntaxKind.NumberKeyword,
+        SyntaxKind.ObjectKeyword,
+        SyntaxKind.StringKeyword,
+        SyntaxKind.SymbolKeyword,
+        SyntaxKind.UndefinedKeyword,
+        SyntaxKind.UnknownKeyword,
+      ],
+      "supportTypePrimitive",
+    ],
+  ];
+
+  for (const [kinds, type] of table) {
+    for (const kind of kinds) {
+      keywords[kind] = type;
+    }
+  }
+
+  return keywords;
+}
+
+/**
+ * A tokenizer for what TypeScript's own tokens leave out of a parsed text: keywords by what they are where they stand, literals,
+ * comments and operators. The identifiers are left to TypeScript, which knows what each is, except the member names it knows
+ * nothing about, a key of a `Record` say, which it leaves out: those are properties all the same. Unless `isScoped`, the keywords
+ * are named as the nearest standard types.
+ */
+export function createSyntaxTokenizer(typescript: typeof ts, isScoped: boolean): SyntaxTokenizer {
+  const keywords = keywordsOf(typescript);
+
+  return (sourceFile, document, checker) => {
+    const text = sourceFile.text;
+    const tokens: SyntaxToken[] = [];
+    const commentEnds = new Set<number>();
+
+    /** Whether an identifier names a member TypeScript has no symbol for, so it will not colour it. */
+    function isUnknownMember(node: ts.Node): boolean {
+      if (!checker || !typescript.isPropertyAccessExpression(node.parent) || node.parent.name !== node) {
+        return false;
+      }
+
+      return checker.getSymbolAtLocation(node) === undefined;
+    }
+
+    /** The comments before a token, each once. */
+    function collectComments(position: number): void {
+      const comments = typescript.getLeadingCommentRanges(text, position) ?? [];
+
+      for (const comment of comments) {
+        if (commentEnds.has(comment.end)) continue;
+
+        commentEnds.add(comment.end);
+        tokens.push(...splitLines(document, comment.pos, comment.end, { type: SemanticTokenTypes.comment, modifiers: [] }));
+      }
+    }
+
+    /** The tokens of a node and what is inside it. */
+    function visit(node: ts.Node): void {
+      const children = node.getChildren(sourceFile);
+
+      if (children.length === 0) {
+        collectComments(node.getFullStart());
+
+        const named = isUnknownMember(node) ? PROPERTY : nameOf(typescript, keywords, node, isScoped);
+        if (named) {
+          tokens.push(...splitLines(document, node.getStart(sourceFile), node.getEnd(), named));
+        }
+
+        return;
+      }
+
+      for (const child of children) {
+        visit(child);
+      }
+    }
+
+    visit(sourceFile);
+    collectComments(sourceFile.endOfFileToken.getFullStart());
+
+    return tokens;
+  };
+}
+
+/** The type and modifiers of a token, or nothing for the identifiers, plain punctuation and anything that is not a token. */
+function nameOf(typescript: typeof ts, keywords: Keywords, node: ts.Node, isScoped: boolean): StandardType | undefined {
+  const { SyntaxKind } = typescript;
+  const kind = node.kind;
+
+  if (kind === SyntaxKind.Identifier) {
+    return node.getText() === "undefined" ? standardOrScoped("constantLanguage", isScoped) : undefined;
+  }
+
+  if (kind === SyntaxKind.StringLiteral || isTemplatePart(typescript, kind)) {
+    return { type: SemanticTokenTypes.string, modifiers: [] };
+  }
+
+  if (kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral) {
+    return { type: SemanticTokenTypes.number, modifiers: [] };
+  }
+
+  if (kind === SyntaxKind.RegularExpressionLiteral) {
+    return { type: SemanticTokenTypes.regexp, modifiers: [] };
+  }
+
+  if (kind >= SyntaxKind.FirstPunctuation && kind <= SyntaxKind.LastPunctuation) {
+    const isOperator = OPERATORS.has(typescript.tokenToString(kind) ?? "");
+
+    return isOperator ? { type: SemanticTokenTypes.operator, modifiers: [] } : undefined;
+  }
+
+  if (kind < SyntaxKind.FirstKeyword || kind > SyntaxKind.LastKeyword) {
+    return undefined;
+  }
+
+  // `void 0` is an operator, `: void` a type
+  if (kind === SyntaxKind.VoidKeyword) {
+    const isOperator = node.parent.kind === SyntaxKind.VoidExpression;
+
+    return standardOrScoped(isOperator ? "keywordOperatorExpression" : "supportTypePrimitive", isScoped);
+  }
+
+  return standardOrScoped(keywords[kind] ?? "keywordControl", isScoped);
+}
+
+/** Whether a kind is one of the pieces a template literal is tokenized into. */
+function isTemplatePart(typescript: typeof ts, kind: ts.SyntaxKind): boolean {
+  const { SyntaxKind } = typescript;
+
+  return (
+    kind === SyntaxKind.NoSubstitutionTemplateLiteral ||
+    kind === SyntaxKind.TemplateHead ||
+    kind === SyntaxKind.TemplateMiddle ||
+    kind === SyntaxKind.TemplateTail
+  );
+}
+
+/** A scoped type itself, or the standard type it stands for. */
+function standardOrScoped(type: ScopedType, isScoped: boolean): StandardType {
+  if (isScoped) {
+    return { type, modifiers: [] };
+  }
+
+  return SCOPED_TYPES[type];
+}
+
+/** A token per line of a stretch of the document, since a token may not span lines. */
+function splitLines(document: TextDocument, start: number, end: number, named: StandardType): SyntaxToken[] {
+  const tokens: SyntaxToken[] = [];
+  const first = document.positionAt(start);
+  const last = document.positionAt(end);
+
+  for (let line = first.line; line <= last.line; line++) {
+    const character = line === first.line ? first.character : 0;
+    const lineEnd =
+      line === last.line
+        ? last.character
+        : document.offsetAt({ line: line + 1, character: 0 }) - document.offsetAt({ line, character: 0 });
+    const length = lineEnd - character;
+
+    if (length > 0) {
+      tokens.push({ line, character, length, ...named });
+    }
+  }
+
+  return tokens;
+}

package/src/helpers/validation.ts

@@ -0,0 +1,94 @@
+import { DiagnosticSeverity } from "vscode-languageserver-protocol";
+
+import type { Project } from "../projects.ts";
+import type { AttributeInfo, DocumentInfo, ElementInfo, ProblemReporter, ProblemTarget, TextRange } from "@staticbolt/core";
+import type { Diagnostic } from "vscode-languageserver-protocol";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+
+/** What diagnostics from plugins are labelled with, followed by the plugin's name. */
+const SOURCE = "staticbolt";
+
+/** What validating a document takes. */
+export interface ValidationInput {
+  /** The document as HTML, where the diagnostics go. */
+  document: TextDocument;
+
+  /** The document as the plugins see it. */
+  info: DocumentInfo;
+
+  /** The project whose plugins validate. */
+  project: Project;
+
+  /** Where a failing plugin is logged. */
+  console: Pick<Console, "error">;
+}
+
+/**
+ * Runs every validating plugin of the project over a document and gathers what they report as diagnostics. A plugin that throws
+ * is skipped, so the others still report, and logged the first time.
+ */
+export async function validateDocument({ document, info, project, console }: ValidationInput): Promise<Diagnostic[]> {
+  const diagnostics: Diagnostic[] = [];
+
+  for (const validator of project.validators) {
+    const report = createReporter(document, validator.name, diagnostics);
+
+    try {
+      await validator.validate(info, report);
+    } catch (error) {
+      if (validator.hasFailed) continue;
+
+      validator.hasFailed = true;
+      console.error(`[staticbolt] the ${validator.name} plugin failed to validate ${info.file}:`, error);
+    }
+  }
+
+  return diagnostics;
+}
+
+/** A reporter adding to `diagnostics`, each one labelled with the plugin it comes from. */
+function createReporter(document: TextDocument, pluginName: string, diagnostics: Diagnostic[]): ProblemReporter {
+  function reportAs(severity: DiagnosticSeverity) {
+    return (target: ProblemTarget, message: string) => {
+      const { start, end } = rangeOf(target);
+
+      diagnostics.push({
+        range: { start: document.positionAt(start), end: document.positionAt(end) },
+        message,
+        severity,
+        source: SOURCE,
+        code: pluginName,
+      });
+    };
+  }
+
+  return {
+    error: reportAs(DiagnosticSeverity.Error),
+    warn: reportAs(DiagnosticSeverity.Warning),
+    info: reportAs(DiagnosticSeverity.Information),
+    hint: reportAs(DiagnosticSeverity.Hint),
+  };
+}
+
+/** An element underlines its tag name, an attribute its value or else its name, a range itself. */
+function rangeOf(target: ProblemTarget): TextRange {
+  if (isElement(target)) {
+    return target.nameRange;
+  }
+
+  if (isAttribute(target)) {
+    return target.valueRange ?? target.nameRange;
+  }
+
+  return target;
+}
+
+/** Only an element has children. */
+function isElement(target: ProblemTarget): target is ElementInfo {
+  return "children" in target;
+}
+
+/** Only an attribute is on an element. */
+function isAttribute(target: ProblemTarget): target is AttributeInfo {
+  return "element" in target;
+}

package/src/helpers/virtual-document.ts

@@ -0,0 +1,111 @@
+import type { EmbeddedRegion, TextRange } from "@staticbolt/core";
+import type * as ts from "typescript";
+
+/**
+ * The text with everything outside the regions blanked, keeping line breaks, so every offset means the same thing as in the text.
+ * The character right after a region becomes a `;`, so neighbouring regions on one line stay separate statements.
+ */
+export function blankAround(text: string, regions: readonly EmbeddedRegion[]): string {
+  let result = "";
+  let cursor = 0;
+
+  for (const region of regions) {
+    result += blank(text.slice(cursor, region.start)) + text.slice(region.start, region.end);
+    cursor = region.end;
+
+    const next = text[cursor];
+
+    if (next === undefined || next === "\n" || next === "\r") continue;
+
+    result += ";";
+    cursor++;
+  }
+
+  return result + blank(text.slice(cursor));
+}
+
+/** The text with the regions blanked, keeping line breaks, so every offset means the same thing as in the text. */
+export function blankRegions(text: string, regions: readonly TextRange[]): string {
+  let result = "";
+  let cursor = 0;
+
+  for (const region of regions) {
+    result += text.slice(cursor, region.start) + blank(text.slice(region.start, region.end));
+    cursor = region.end;
+  }
+
+  return result + text.slice(cursor);
+}
+
+/**
+ * The holes masked, keeping line breaks, so the code around them still parses and types as it will once they are filled: a hole
+ * in a string literal makes the whole literal `("" + "")`, a `string` rather than a literal type; a hole in a template becomes a
+ * `${<any>0}` substitution, for the same reason; any other hole reads as `(<any>0)`, a value of a type nobody knows yet.
+ *
+ * A mask stands where an expression stands, so it is parenthesised: whatever surrounds it, `+"{{ n }}"` say, binds to the mask as
+ * a whole and not to a part of it. A hole too short for its mask gets the longest shorter one that fits, down to nothing.
+ */
+export function mask(typescript: typeof ts, text: string, holes: readonly TextRange[]): string {
+  if (holes.length === 0) {
+    return text;
+  }
+
+  const sourceFile = typescript.createSourceFile("mask.ts", text, typescript.ScriptTarget.Latest, true);
+  let result = text;
+
+  for (const hole of holes) {
+    const token = tokenAt(sourceFile, hole.start);
+
+    if (token?.kind === typescript.SyntaxKind.StringLiteral) {
+      const range = { start: token.getStart(sourceFile), end: token.getEnd() };
+
+      result = replace(result, range, fill(text.slice(range.start, range.end), '("" + "")', '(""+"")', '("")', '""'));
+      continue;
+    }
+
+    if (token && typescript.isTemplateLiteralToken(token)) {
+      result = replace(result, hole, fill(text.slice(hole.start, hole.end), "${<any>0}", "${0}"));
+      continue;
+    }
+
+    result = replace(result, hole, fill(text.slice(hole.start, hole.end), "(<any>0)", "<any>0", "(0)", "0"));
+  }
+
+  return result;
+}
+
+/**
+ * The first replacement the original has room for, followed by the rest of the original blanked, so the length and the line
+ * breaks are kept; nothing but the blanks when even the shortest is too long.
+ */
+function fill(original: string, ...replacements: readonly string[]): string {
+  const fitting = replacements.find(replacement => replacement.length <= original.length) ?? "";
+
+  return fitting + blank(original.slice(fitting.length));
+}
+
+/** The token of a parsed text an offset falls in: the deepest node there that has no children. */
+function tokenAt(sourceFile: ts.SourceFile, offset: number): ts.Node | undefined {
+  let node: ts.Node = sourceFile;
+
+  while (true) {
+    const child = node
+      .getChildren(sourceFile)
+      .find(candidate => candidate.getStart(sourceFile) <= offset && offset < candidate.getEnd());
+    if (!child) {
+      return node === sourceFile ? undefined : node;
+    }
+
+    node = child;
+  }
+}
+
+/** The text with a range replaced by a replacement of the same length. */
+function replace(text: string, range: TextRange, replacement: string): string {
+  return text.slice(0, range.start) + replacement + text.slice(range.end);
+}
+
+/** Every character but the line breaks replaced by a space. */
+function blank(text: string): string {
+  return text.replaceAll(/[^\n\r]/g, " ");
+}