@likec4/language-server 1.18.0 → 1.19.0

package/dist/likec4lib.d.ts

@@ -1,6 +1,4 @@
-declare const LibIcons: string;
-
-declare const Scheme = "likec4builtin";
-declare const Uri: "likec4builtin:///likec4/lib/icons.c4";
-
-export { LibIcons as Content, Scheme, Uri };
+import { LibIcons } from './generated-lib/icons';
+export declare const Scheme = "likec4builtin";
+export declare const Uri: "likec4builtin:///likec4/lib/icons.c4";
+export { LibIcons as Content };

package/dist/likec4lib.js

@@ -0,0 +1,4 @@
+import { LibIcons } from "./generated-lib/icons.js";
+export const Scheme = "likec4builtin";
+export const Uri = `${Scheme}:///likec4/lib/icons.c4`;
+export { LibIcons as Content };

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+import { LogLevels } from '@likec4/log';
+import type { Connection } from 'vscode-languageserver';
+export declare const logger: any;
+export declare function logError(err: unknown): void;
+export declare function logWarnError(err: unknown): void;
+export declare function setLogLevel(level: keyof typeof LogLevels): void;
+export declare function logToLspConnection(connection: Connection): void;

package/dist/logger.js

@@ -0,0 +1,73 @@
+import { nonexhaustive } from "@likec4/core";
+import { formatLogObj, LogLevels, rootLogger as root } from "@likec4/log";
+import { BROWSER } from "esm-env";
+export const logger = root.withTag("lsp");
+export function logError(err) {
+  logger.error(err);
+}
+export function logWarnError(err) {
+  if (err instanceof Error) {
+    logger.warn(err.stack ?? err.message);
+    return;
+  }
+  logger.warn(err);
+}
+export function setLogLevel(level) {
+  logger.level = LogLevels[level];
+}
+export function logToLspConnection(connection) {
+  const reporter = {
+    log: (logObj, _ctx) => {
+      const { message, error } = formatLogObj(logObj);
+      switch (logObj.type) {
+        case "silent": {
+          break;
+        }
+        case "verbose":
+        case "trace": {
+          connection.tracer.log(message);
+          break;
+        }
+        case "debug": {
+          connection.console.debug(message);
+          break;
+        }
+        case "log": {
+          connection.console.log(message);
+          break;
+        }
+        case "info":
+        case "box":
+        case "ready":
+        case "start":
+        case "success": {
+          connection.console.info(message);
+          break;
+        }
+        case "warn": {
+          connection.console.warn(message);
+          break;
+        }
+        case "fail":
+        case "error":
+        case "fatal": {
+          connection.console.error(message);
+          if (error) {
+            connection.telemetry.logEvent({ eventName: "error", ...error });
+          } else {
+            connection.telemetry.logEvent({ eventName: "error", message });
+          }
+          break;
+        }
+        default:
+          nonexhaustive(logObj.type);
+      }
+    }
+  };
+  if (BROWSER) {
+    root.addReporter(reporter);
+  } else {
+    root.setReporters([reporter]);
+  }
+  logger.setReporters(root.options.reporters);
+}

package/dist/lsp/CodeLensProvider.d.ts

@@ -0,0 +1,9 @@
+import { type LangiumDocument } from 'langium';
+import type { CodeLensProvider } from 'langium/lsp';
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
+}

package/dist/lsp/CodeLensProvider.js

@@ -0,0 +1,40 @@
+import { DocumentState } from "langium";
+import { isParsedLikeC4LangiumDocument, ViewOps } from "../ast.js";
+import { logger } from "../logger.js";
+export class LikeC4CodeLensProvider {
+  constructor(services) {
+    this.services = services;
+  }
+  async provideCodeLens(doc, _params, cancelToken) {
+    if (doc.state !== DocumentState.Validated) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be validated`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
+      logger.debug(`Document ${doc.uri.path} is validated`);
+    }
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return;
+    }
+    const views = doc.parseResult.value.views.flatMap((v) => v.views);
+    return views.flatMap((ast) => {
+      const viewId = ViewOps.readId(ast);
+      const range = ast.$cstNode?.range;
+      if (!range || !viewId) {
+        return [];
+      }
+      return {
+        range: {
+          start: range.start,
+          end: {
+            line: range.start.line,
+            character: range.start.character + 4
+          }
+        },
+        command: {
+          command: "likec4.open-preview",
+          arguments: [viewId],
+          title: "open preview"
+        }
+      };
+    });
+  }
+}

package/dist/lsp/CompletionProvider.d.ts

@@ -0,0 +1,6 @@
+import { type GrammarAST, type MaybePromise } from 'langium';
+import { type CompletionAcceptor, type CompletionContext, DefaultCompletionProvider } from 'langium/lsp';
+export declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+    readonly completionOptions: CompletionProviderOptions;
+    protected completionForKeyword(context: CompletionContext, keyword: GrammarAST.Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
+}

package/dist/lsp/CompletionProvider.js

@@ -0,0 +1,135 @@
+import { AstUtils } from "langium";
+import {
+  DefaultCompletionProvider
+} from "langium/lsp";
+import { anyPass } from "remeda";
+import { CompletionItemKind, InsertTextFormat } from "vscode-languageserver-types";
+import { ast } from "../ast.js";
+export class LikeC4CompletionProvider extends DefaultCompletionProvider {
+  completionOptions = {
+    triggerCharacters: ["."]
+  };
+  completionForKeyword(context, keyword, acceptor) {
+    if (!this.filterKeyword(context, keyword)) {
+      return;
+    }
+    if (keyword.value === "deployment" && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert deployment view`,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: [
+          "deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {",
+          "	title '${2:Untitled}'",
+          "	",
+          "	include $0",
+          "}"
+        ].join("\n")
+      });
+    }
+    if (["title", "description", "technology"].includes(keyword.value)) {
+      return acceptor(context, {
+        label: keyword.value,
+        kind: CompletionItemKind.Property,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: `${keyword.value} '\${0}'`
+      });
+    }
+    if (["views", "specification", "model", "deployment", "with"].includes(keyword.value)) {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert ${keyword.value} block`,
+        kind: CompletionItemKind.Module,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: `${keyword.value} {
+	$0
+}`
+      });
+    }
+    if (keyword.value === "group") {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert group block`,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: [
+          "group '${1:Title}' {",
+          "	$0",
+          "}"
+        ].join("\n")
+      });
+    }
+    if (keyword.value === "dynamic" && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert dynamic view`,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: [
+          "dynamic view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {",
+          "	title '${2:Untitled}'",
+          "	",
+          "	$0",
+          "}"
+        ].join("\n")
+      });
+    }
+    if (keyword.value === "style" && context.node) {
+      if (AstUtils.hasContainerOfType(context.node, ast.isGlobalStyle)) {
+        return acceptor(context, {
+          label: keyword.value,
+          detail: `Insert ${keyword.value} block`,
+          kind: CompletionItemKind.Module,
+          insertTextFormat: InsertTextFormat.Snippet,
+          insertText: `${keyword.value} \${1:name} \${2:*} {
+	\${3|color,shape,border,opacity,icon|} $0
+}`
+        });
+      }
+      if (AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup]))) {
+        return acceptor(context, {
+          label: keyword.value,
+          detail: `Insert ${keyword.value} block`,
+          kind: CompletionItemKind.Module,
+          insertTextFormat: InsertTextFormat.Snippet,
+          insertText: `${keyword.value} \${1:*} {
+	\${2|color,shape,border,opacity,icon|} $0
+}`
+        });
+      }
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert ${keyword.value} block`,
+        kind: CompletionItemKind.Module,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: `${keyword.value} {
+	\${1|color,shape,border,opacity,icon|} $0
+}`
+      });
+    }
+    if (keyword.value === "extend") {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Extend another view`,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "extend ${1:element} {\n	$0\n}"
+      });
+    }
+    if (keyword.value === "autoLayout") {
+      return acceptor(context, {
+        label: keyword.value,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "autoLayout ${1|TopBottom,BottomTop,LeftRight,RightLeft|}$0"
+      });
+    }
+    acceptor(context, {
+      label: keyword.value,
+      kind: this.getKeywordCompletionItemKind(keyword),
+      detail: "Keyword",
+      sortText: "1"
+    });
+  }
+}

package/dist/lsp/DocumentHighlightProvider.d.ts

@@ -0,0 +1,9 @@
+import type { ReferenceDescription } from 'langium';
+import { DefaultDocumentHighlightProvider } from 'langium/lsp';
+import { DocumentHighlight } from 'vscode-languageserver';
+export declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+    /**
+     * Override this method to determine the highlight kind of the given reference.
+     */
+    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+}

package/dist/lsp/DocumentHighlightProvider.js

@@ -0,0 +1,10 @@
+import { DefaultDocumentHighlightProvider } from "langium/lsp";
+import { DocumentHighlight, DocumentHighlightKind } from "vscode-languageserver";
+export class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+  /**
+   * Override this method to determine the highlight kind of the given reference.
+   */
+  createDocumentHighlight(reference) {
+    return DocumentHighlight.create(reference.segment.range, DocumentHighlightKind.Read);
+  }
+}

package/dist/lsp/DocumentLinkProvider.d.ts

@@ -0,0 +1,11 @@
+import type { LangiumDocument, MaybePromise } from 'langium';
+import type { DocumentLinkProvider } from 'langium/lsp';
+import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+    resolveLink(doc: LangiumDocument, link: string): string;
+    relativeLink(doc: LangiumDocument, link: string): string | null;
+}

package/dist/lsp/DocumentLinkProvider.js

@@ -0,0 +1,49 @@
+import { AstUtils, GrammarUtils } from "langium";
+import { hasLeadingSlash, hasProtocol, isRelative, withoutBase, withoutLeadingSlash } from "ufo";
+import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
+import { logWarnError } from "../logger.js";
+export class LikeC4DocumentLinkProvider {
+  constructor(services) {
+    this.services = services;
+  }
+  getDocumentLinks(doc, _params) {
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return [];
+    }
+    return AstUtils.streamAllContents(doc.parseResult.value).filter(ast.isLinkProperty).map((n) => {
+      try {
+        const range = GrammarUtils.findNodeForProperty(n.$cstNode, "value")?.range;
+        const target = this.resolveLink(doc, n.value);
+        if (range && hasProtocol(target)) {
+          return {
+            range,
+            target
+          };
+        }
+      } catch (e) {
+        logWarnError(e);
+      }
+      return null;
+    }).nonNullable().toArray();
+  }
+  resolveLink(doc, link) {
+    if (hasProtocol(link) || hasLeadingSlash(link)) {
+      return link;
+    }
+    const base = isRelative(link) ? new URL(doc.uri.toString(true)) : this.services.shared.workspace.WorkspaceManager.workspaceURL;
+    return new URL(link, base).toString();
+  }
+  relativeLink(doc, link) {
+    if (hasLeadingSlash(link)) {
+      return withoutLeadingSlash(link);
+    }
+    if (isRelative(link)) {
+      const base = new URL(doc.uri.toString(true));
+      const linkURL = new URL(link, base).toString();
+      return withoutLeadingSlash(
+        withoutBase(linkURL, this.services.shared.workspace.WorkspaceManager.workspaceURL.toString())
+      );
+    }
+    return null;
+  }
+}

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -0,0 +1,23 @@
+import { type AstNode, type MaybePromise } from 'langium';
+import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp';
+import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types';
+import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+    private services;
+    protected readonly nodeKindProvider: NodeKindProvider;
+    constructor(services: LikeC4Services);
+    getSymbols({ parseResult: { value: { specifications, models, views, likec4lib } } }: LikeC4LangiumDocument): MaybePromise<DocumentSymbol[]>;
+    protected getLikec4LibSymbol(astLib: ast.LikeC4Lib): DocumentSymbol[];
+    protected getSpecSymbol(astSpec: ast.SpecificationRule): DocumentSymbol[];
+    protected getModelSymbol(astModel: ast.Model): DocumentSymbol[];
+    protected getElementsSymbol(el: ast.Element | ast.Relation | ast.ExtendElement): DocumentSymbol[];
+    protected getExtendElementSymbol(astElement: ast.ExtendElement): DocumentSymbol[];
+    protected getElementSymbol(astElement: ast.Element): DocumentSymbol[];
+    protected getModelViewsSymbol(astViews: ast.ModelViews): DocumentSymbol[];
+    protected getKindSymbol(astKind: ast.SpecificationElementKind | ast.SpecificationRelationshipKind): DocumentSymbol | null;
+    protected getTagSymbol(astTag: ast.SpecificationTag): DocumentSymbol | null;
+    protected getLibIconSymbol(astTag: ast.LibIcon): DocumentSymbol | null;
+    protected getViewSymbol(astView: ast.LikeC4View): DocumentSymbol[];
+    protected symbolKind(node: AstNode): SymbolKind;
+}

package/dist/lsp/DocumentSymbolProvider.js

@@ -0,0 +1,202 @@
+import { nonexhaustive } from "@likec4/core";
+import { GrammarUtils } from "langium";
+import { filter, isEmpty, isTruthy, map, pipe } from "remeda";
+import { SymbolKind } from "vscode-languageserver-types";
+import { ast } from "../ast.js";
+import { logError } from "../logger.js";
+import { getFqnElementRef } from "../utils/elementRef.js";
+export class LikeC4DocumentSymbolProvider {
+  constructor(services) {
+    this.services = services;
+    this.nodeKindProvider = services.shared.lsp.NodeKindProvider;
+  }
+  nodeKindProvider;
+  getSymbols({
+    parseResult: {
+      value: { specifications, models, views, likec4lib }
+    }
+  }) {
+    return [
+      ...likec4lib.map((l) => () => this.getLikec4LibSymbol(l)),
+      ...specifications.map((s) => () => this.getSpecSymbol(s)),
+      ...models.map((s) => () => this.getModelSymbol(s)),
+      ...views.map((s) => () => this.getModelViewsSymbol(s))
+    ].flatMap((fn) => {
+      try {
+        return fn() ?? [];
+      } catch (e) {
+        logError(e);
+        return [];
+      }
+    });
+  }
+  getLikec4LibSymbol(astLib) {
+    const cstModel = astLib?.$cstNode;
+    if (!cstModel) return [];
+    const children = astLib.icons.map((i) => this.getLibIconSymbol(i)).filter(isTruthy);
+    if (children.length === 0) return [];
+    return [
+      {
+        kind: SymbolKind.Namespace,
+        name: "icons",
+        range: cstModel.range,
+        selectionRange: GrammarUtils.findNodeForKeyword(cstModel, "icons")?.range ?? cstModel.range,
+        children
+      }
+    ];
+  }
+  getSpecSymbol(astSpec) {
+    const cstModel = astSpec?.$cstNode;
+    if (!cstModel) return [];
+    const specKeywordNode = GrammarUtils.findNodeForProperty(cstModel, "name");
+    if (!specKeywordNode) return [];
+    const specSymbols = pipe(
+      [...astSpec.elements, ...astSpec.tags, ...astSpec.relationships],
+      map((nd) => {
+        try {
+          if (ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd) || ast.isSpecificationDeploymentNodeKind(nd)) {
+            return this.getKindSymbol(nd);
+          }
+          if (ast.isSpecificationTag(nd)) {
+            return this.getTagSymbol(nd);
+          }
+        } catch (e) {
+          logError(e);
+          return null;
+        }
+        nonexhaustive(nd);
+      }),
+      filter(isTruthy)
+    );
+    if (specSymbols.length === 0) return [];
+    return [
+      {
+        kind: SymbolKind.Namespace,
+        name: astSpec.name,
+        range: cstModel.range,
+        selectionRange: specKeywordNode.range,
+        children: specSymbols
+      }
+    ];
+  }
+  getModelSymbol(astModel) {
+    const cstModel = astModel.$cstNode;
+    if (!cstModel) return [];
+    const nameNode = GrammarUtils.findNodeForProperty(cstModel, "name");
+    if (!nameNode) return [];
+    return [
+      {
+        kind: this.symbolKind(astModel),
+        name: astModel.name,
+        range: cstModel.range,
+        selectionRange: nameNode.range,
+        children: astModel.elements.flatMap((e) => this.getElementsSymbol(e))
+      }
+    ];
+  }
+  getElementsSymbol(el) {
+    try {
+      if (ast.isExtendElement(el)) {
+        return this.getExtendElementSymbol(el);
+      }
+      if (ast.isElement(el)) {
+        return this.getElementSymbol(el);
+      }
+    } catch (e) {
+      logError(e);
+    }
+    return [];
+  }
+  getExtendElementSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = astElement.element.$cstNode;
+    const body = astElement.body;
+    if (!cst || !nameNode) return [];
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name: getFqnElementRef(astElement.element),
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: body.elements.flatMap((e) => this.getElementsSymbol(e))
+      }
+    ];
+  }
+  getElementSymbol(astElement) {
+    const cst = astElement.$cstNode;
+    const nameNode = GrammarUtils.findNodeForProperty(cst, "name");
+    if (!nameNode || !cst) return [];
+    const name = astElement.name;
+    const kind = astElement.kind.$refText;
+    const detail = kind;
+    return [
+      {
+        kind: this.symbolKind(astElement),
+        name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        detail,
+        children: astElement.body?.elements.flatMap((e) => this.getElementsSymbol(e)) ?? []
+      }
+    ];
+  }
+  getModelViewsSymbol(astViews) {
+    const cst = astViews.$cstNode;
+    const nameNode = GrammarUtils.findNodeForProperty(cst, "name");
+    if (!nameNode || !cst) return [];
+    return [
+      {
+        kind: this.symbolKind(astViews),
+        name: astViews.name,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: astViews.views.flatMap((e) => this.getViewSymbol(e))
+      }
+    ];
+  }
+  getKindSymbol(astKind) {
+    if (!astKind.$cstNode || !astKind.kind.$cstNode || isEmpty(astKind.kind.name)) return null;
+    return {
+      kind: this.symbolKind(astKind),
+      name: astKind.kind.name,
+      range: astKind.$cstNode.range,
+      selectionRange: astKind.kind.$cstNode.range
+    };
+  }
+  getTagSymbol(astTag) {
+    if (!astTag.$cstNode || !astTag.tag.$cstNode || isEmpty(astTag.tag.name)) return null;
+    return {
+      kind: this.symbolKind(astTag),
+      name: "#" + astTag.tag.name,
+      range: astTag.$cstNode.range,
+      selectionRange: astTag.tag.$cstNode.range
+    };
+  }
+  getLibIconSymbol(astTag) {
+    if (!astTag.$cstNode || isEmpty(astTag.name)) return null;
+    return {
+      kind: this.symbolKind(astTag),
+      name: astTag.name,
+      range: astTag.$cstNode.range,
+      selectionRange: astTag.$cstNode.range
+    };
+  }
+  getViewSymbol(astView) {
+    const cst = astView?.$cstNode;
+    if (!cst) return [];
+    const nameNode = astView.name ? GrammarUtils.findNodeForProperty(cst, "name") : null;
+    if (!nameNode) return [];
+    return [
+      {
+        kind: this.symbolKind(astView),
+        name: nameNode.text,
+        range: cst.range,
+        selectionRange: nameNode.range,
+        children: []
+      }
+    ];
+  }
+  symbolKind(node) {
+    return this.nodeKindProvider.getSymbolKind(node);
+  }
+}

package/dist/lsp/HoverProvider.d.ts

@@ -0,0 +1,10 @@
+import { type AstNode, type MaybePromise } from 'langium';
+import { AstNodeHoverProvider } from 'langium/lsp';
+import type { Hover } from 'vscode-languageserver-types';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4HoverProvider extends AstNodeHoverProvider {
+    private parser;
+    private locator;
+    constructor(services: LikeC4Services);
+    protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+}

package/dist/lsp/HoverProvider.js

@@ -0,0 +1,69 @@
+import { AstUtils } from "langium";
+import { AstNodeHoverProvider } from "langium/lsp";
+import stripIndent from "strip-indent";
+import { ast } from "../ast.js";
+export class LikeC4HoverProvider extends AstNodeHoverProvider {
+  parser;
+  locator;
+  constructor(services) {
+    super(services);
+    this.parser = services.likec4.ModelParser;
+    this.locator = services.likec4.ModelLocator;
+  }
+  getAstNodeHoverContent(node) {
+    if (ast.isTag(node)) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: stripIndent(`
+            tag: \`${node.name}\`
+          `)
+        }
+      };
+    }
+    if (ast.isDeploymentNode(node)) {
+      const doc = AstUtils.getDocument(node);
+      const el = this.parser.forDocument(doc).parseDeploymentNode(node);
+      const lines = [el.id + "  "];
+      if (el.title !== node.name) {
+        lines.push(`### ${el.title}`);
+      }
+      lines.push("Deployment: `" + el.kind + "` ");
+      return {
+        contents: {
+          kind: "markdown",
+          value: lines.join("\n")
+        }
+      };
+    }
+    if (ast.isDeployedInstance(node)) {
+      const doc = AstUtils.getDocument(node);
+      const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
+      const el = this.locator.getParsedElement(instance.element);
+      const lines = [instance.id + "  ", `instance of \`${instance.element}\``];
+      if (el) {
+        lines.push(`### ${el.title}`, "Element: `" + el.kind + "` ");
+      }
+      return {
+        contents: {
+          kind: "markdown",
+          value: lines.join("\n")
+        }
+      };
+    }
+    if (ast.isElement(node)) {
+      const el = this.locator.getParsedElement(node);
+      if (!el) {
+        return;
+      }
+      const lines = [el.id, `### ${el.title}`, "Element: `" + el.kind + "` "];
+      return {
+        contents: {
+          kind: "markdown",
+          value: lines.join("\n")
+        }
+      };
+    }
+    return;
+  }
+}