320 lines
11 KiB
TypeScript
320 lines
11 KiB
TypeScript
import * as vscode from "vscode";
|
|
import { findElementAt, textContentTokenAt } from "../language/xmlParser";
|
|
import { resolveElementType } from "../language/typeContext";
|
|
import * as model from "../model/schemaModel";
|
|
import type { ModWorkspace } from "../workspace";
|
|
import {
|
|
isLocalReferenceAttribute,
|
|
isReferenceAttributeOfType,
|
|
isReferenceContentType,
|
|
resolveContentReferenceTargets,
|
|
resolveReferenceTargetsForType,
|
|
type ReferenceTarget,
|
|
} from "../indexer/refs";
|
|
import {
|
|
findContainingGameObject,
|
|
findLocalId,
|
|
type LogicalElement,
|
|
} from "../indexer/logicalTree";
|
|
import { scopePathKey, type DocumentScope } from "../indexer/localScope";
|
|
import { dirname } from "node:path";
|
|
import { buildSearchPaths, resolveSource } from "../indexer/includeResolver";
|
|
|
|
export class Ra3HoverProvider implements vscode.HoverProvider {
|
|
constructor(private ws: ModWorkspace) {}
|
|
|
|
async provideHover(
|
|
document: vscode.TextDocument,
|
|
position: vscode.Position,
|
|
_token: vscode.CancellationToken,
|
|
): Promise<vscode.Hover | null> {
|
|
if (!this.ws.isRa3Workspace()) return null;
|
|
const offset = document.offsetAt(position);
|
|
const text = document.getText();
|
|
const scope = await this.ws.getScope(document);
|
|
const doc = scope.expanded;
|
|
const el = findElementAt(doc, offset);
|
|
if (!el) return null;
|
|
const elType = resolveElementType(el);
|
|
|
|
// Attribute name.
|
|
for (const attr of el.attrs) {
|
|
if (offset >= attr.nameStart && offset <= attr.nameEnd) {
|
|
return this.attributeHover(el, elType, attr.name);
|
|
}
|
|
}
|
|
// Attribute value.
|
|
for (const attr of el.attrs) {
|
|
if (attr.hasValue && offset >= attr.valueStart && offset <= attr.valueEnd) {
|
|
return this.valueHover(el, elType, attr.name, attr.value, document, scope);
|
|
}
|
|
}
|
|
// Element text content (e.g. <CreateObject>CrateDebris_01</CreateObject>).
|
|
const contentToken = textContentTokenAt(text, el, offset);
|
|
if (contentToken) {
|
|
const h = this.contentHover(elType, contentToken.value, document, scope);
|
|
if (h) return h;
|
|
}
|
|
// Element name.
|
|
const nameStart = el.start + 1;
|
|
if (offset >= nameStart && offset <= nameStart + el.name.length) {
|
|
return this.elementHover(el.name);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private elementHover(name: string): vscode.Hover | null {
|
|
if (name.startsWith("xi:")) {
|
|
const md = new vscode.MarkdownString();
|
|
md.appendCodeblock(`<${name}>`, "xml");
|
|
md.appendMarkdown(
|
|
"XInclude element (W3C XInclude namespace) — not part of the RA3 XSD model.",
|
|
);
|
|
return new vscode.Hover(md);
|
|
}
|
|
const type = model.elementTypeName(name);
|
|
const info = type ? model.typeInfo(type) : undefined;
|
|
const md = new vscode.MarkdownString();
|
|
md.appendCodeblock(`<${name}>`, "xml");
|
|
if (model.isTopLevelElement(name)) md.appendMarkdown(`**Top-level asset element** \n`);
|
|
if (info?.kind === "complex") {
|
|
if (info.doc) md.appendMarkdown(`${info.doc} \n`);
|
|
md.appendMarkdown(
|
|
`Attributes: ${info.attributes.length} · Children: ${info.children.length} \n`,
|
|
);
|
|
if (info.base) md.appendMarkdown(`Extends: \`${info.base}\``);
|
|
} else if (info?.kind === "simple") {
|
|
md.appendMarkdown(`Simple type: \`${type}\``);
|
|
} else if (type) {
|
|
md.appendMarkdown(`Type: \`${type}\``);
|
|
} else {
|
|
md.appendMarkdown("Not found in the bundled XSD model.");
|
|
}
|
|
return new vscode.Hover(md);
|
|
}
|
|
|
|
private attributeHover(
|
|
el: { name: string },
|
|
elementType: string | null,
|
|
attrName: string,
|
|
): vscode.Hover | null {
|
|
const attrs = model.attributesOfType(elementType);
|
|
const attr = attrs.find((a) => a.name === attrName);
|
|
const md = new vscode.MarkdownString();
|
|
md.appendCodeblock(`${attrName}=""`, "xml");
|
|
if (!attr) {
|
|
if (/^(xmlns|xai:)/.test(attrName)) {
|
|
md.appendMarkdown(`Namespace/instance attribute.`);
|
|
return new vscode.Hover(md);
|
|
}
|
|
if (!model.isXsdElementName(el.name)) {
|
|
md.appendMarkdown(
|
|
`XInclude attribute (W3C XInclude namespace) — not part of the RA3 XSD model.`,
|
|
);
|
|
return new vscode.Hover(md);
|
|
}
|
|
md.appendMarkdown("Unknown attribute for this element.");
|
|
return new vscode.Hover(md);
|
|
}
|
|
if (attr.doc) md.appendMarkdown(`${attr.doc} \n`);
|
|
if (attr.required) md.appendMarkdown(`**Required** \n`);
|
|
if (attr.refType) md.appendMarkdown(`References assets of type \`${attr.refType}\` \n`);
|
|
if (attr.enumValues.length)
|
|
md.appendMarkdown(`Values: \`${attr.enumValues.join("`, `")}\` \n`);
|
|
if (attr.default != null) md.appendMarkdown(`Default: \`${attr.default}\` \n`);
|
|
if (attr.allowsDefine) md.appendMarkdown(`May use \`$DEFINE\` constants \n`);
|
|
md.appendMarkdown(`Type: \`${attr.type ?? "string"}\``);
|
|
return new vscode.Hover(md);
|
|
}
|
|
|
|
private valueHover(
|
|
el: { name: string },
|
|
elType: string | null,
|
|
attrName: string,
|
|
value: string,
|
|
document: vscode.TextDocument,
|
|
scope: DocumentScope,
|
|
): vscode.Hover | null {
|
|
const idx = scope.merged;
|
|
const md = new vscode.MarkdownString();
|
|
|
|
// $DEFINE reference.
|
|
const defineMatch = /\$([A-Za-z_][A-Za-z0-9_]*)/.exec(value);
|
|
if (defineMatch && idx) {
|
|
const defs =
|
|
idx.local?.defines.get(defineMatch[1].toLowerCase()) ??
|
|
idx.defines.get(defineMatch[1].toLowerCase());
|
|
const h = this.defineHover(defs, document);
|
|
if (h) return h;
|
|
}
|
|
|
|
// Include source.
|
|
if (
|
|
(el.name === "Include" && attrName === "source") ||
|
|
(el.name === "xi:include" && attrName === "href")
|
|
) {
|
|
const searchPaths = idx
|
|
? buildSearchPaths(idx.sdkDir, idx.projectDir)
|
|
: this.ws.searchPaths();
|
|
const resolved = searchPaths
|
|
? resolveSource(
|
|
value,
|
|
dirname(document.uri.fsPath),
|
|
searchPaths,
|
|
).path
|
|
: null;
|
|
if (resolved) {
|
|
md.appendMarkdown(`**Include source** \n`);
|
|
md.appendCodeblock(resolved);
|
|
return new vscode.Hover(md);
|
|
}
|
|
const cand = idx?.sourceCandidates.find((c) => c.source === value);
|
|
if (cand) {
|
|
md.appendMarkdown(`**Include source** \n`);
|
|
md.appendCodeblock(cand.path);
|
|
return new vscode.Hover(md);
|
|
}
|
|
md.appendMarkdown(`Include source: \`${value}\` (not in candidate index)`);
|
|
return new vscode.Hover(md);
|
|
}
|
|
|
|
// Pipeline-local (Poid) references: resolve inside the enclosing
|
|
// GameObject's logical subtree (including xi:include targets).
|
|
if (
|
|
isLocalReferenceAttribute(elType, attrName) &&
|
|
attrName.toLowerCase() !== "id"
|
|
) {
|
|
return this.localIdHover(scope, el as LogicalElement, value, document);
|
|
}
|
|
|
|
// Asset reference / inheritFrom.
|
|
if (!idx) {
|
|
if (isReferenceAttributeOfType(elType, attrName)) {
|
|
md.appendMarkdown(
|
|
"Index is still building — references cannot be resolved yet.",
|
|
);
|
|
return new vscode.Hover(md);
|
|
}
|
|
return null;
|
|
}
|
|
{
|
|
if (!isReferenceAttributeOfType(elType, attrName)) return null;
|
|
const targets = resolveReferenceTargetsForType(idx, elType, attrName, value);
|
|
if (targets.length) return this.definitionsHover(targets, document);
|
|
const attrRef = model
|
|
.attributesOfType(elType)
|
|
.find((a) => a.name === attrName);
|
|
const expected = attrRef?.refType
|
|
? ` of type \`${attrRef.refType}\``
|
|
: attrRef?.isRef
|
|
? " of the expected declared type"
|
|
: "";
|
|
return this.noDefinitionHover(expected);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hover for text inside a simple-content element whose type is a typed
|
|
* asset reference (e.g. <CreateObject> with GameObjectWeakRef).
|
|
*/
|
|
private contentHover(
|
|
elType: string | null,
|
|
value: string,
|
|
document: vscode.TextDocument,
|
|
scope: DocumentScope,
|
|
): vscode.Hover | null {
|
|
const idx = scope.merged;
|
|
const defineMatch = /\$([A-Za-z_][A-Za-z0-9_]*)/.exec(value);
|
|
if (defineMatch && idx) {
|
|
const defs =
|
|
idx.local?.defines.get(defineMatch[1].toLowerCase()) ??
|
|
idx.defines.get(defineMatch[1].toLowerCase());
|
|
const h = this.defineHover(defs, document);
|
|
if (h) return h;
|
|
}
|
|
if (!isReferenceContentType(elType)) return null;
|
|
if (!idx) {
|
|
const md = new vscode.MarkdownString();
|
|
md.appendMarkdown("Index is still building — references cannot be resolved yet.");
|
|
return new vscode.Hover(md);
|
|
}
|
|
const targets = resolveContentReferenceTargets(idx, elType, value);
|
|
if (targets.length) return this.definitionsHover(targets, document);
|
|
const info = elType ? model.typeInfo(elType) : undefined;
|
|
const refType = info?.kind === "simple" ? info.refType : null;
|
|
return this.noDefinitionHover(
|
|
refType ? ` of type \`${refType}\`` : " of the expected declared type",
|
|
);
|
|
}
|
|
|
|
private defineHover(
|
|
defs: { name: string; value: string; file: string; line: number }[] | undefined,
|
|
document: vscode.TextDocument,
|
|
): vscode.Hover | null {
|
|
if (!defs?.length) return null;
|
|
const d = defs[0];
|
|
const md = new vscode.MarkdownString();
|
|
md.appendMarkdown(`**Define** \`$${d.name}\` \n`);
|
|
md.appendCodeblock(d.value);
|
|
const rel = relativePath(document, d.file);
|
|
md.appendMarkdown(`Defined in \`${rel}:${d.line}\``);
|
|
return new vscode.Hover(md);
|
|
}
|
|
|
|
private definitionsHover(
|
|
targets: ReferenceTarget[],
|
|
document: vscode.TextDocument,
|
|
): vscode.Hover {
|
|
const md2 = new vscode.MarkdownString();
|
|
md2.appendMarkdown(`**${targets.length} definition${targets.length > 1 ? "s" : ""}** \n`);
|
|
for (const { def: d } of targets.slice(0, 8)) {
|
|
const loc =
|
|
d.origin === "manifest"
|
|
? `manifest \`${d.manifestSource ?? d.file}\``
|
|
: `\`${relativePath(document, d.file)}:${d.line}\``;
|
|
md2.appendMarkdown(`- \`${d.type}\` · ${loc} \n`);
|
|
}
|
|
return new vscode.Hover(md2);
|
|
}
|
|
|
|
private noDefinitionHover(expected: string): vscode.Hover {
|
|
const md = new vscode.MarkdownString();
|
|
md.appendMarkdown(
|
|
`No matching definition${expected} in the current index` +
|
|
" (may exist in a compiled manifest or vanilla data).",
|
|
);
|
|
return new vscode.Hover(md);
|
|
}
|
|
|
|
private localIdHover(
|
|
scope: DocumentScope,
|
|
el: LogicalElement,
|
|
value: string,
|
|
document: vscode.TextDocument,
|
|
): vscode.Hover | null {
|
|
const root = findContainingGameObject(el);
|
|
if (!root) return null;
|
|
const target = findLocalId(root, value);
|
|
if (!target) return null;
|
|
const idAttr = target.attrs.find((a) => a.name === "id");
|
|
if (!idAttr?.hasValue) return null;
|
|
const lineMap = scope.lineMaps.get(scopePathKey(target.sourceFile));
|
|
const line = lineMap ? lineMap.positionAt(idAttr.valueStart).line + 1 : 0;
|
|
const md = new vscode.MarkdownString();
|
|
md.appendMarkdown(`**Local pipeline id** \`${value}\` \n`);
|
|
md.appendCodeblock(`<${target.name}>`);
|
|
const rel = relativePath(document, target.sourceFile);
|
|
md.appendMarkdown(`Defined in \`${rel}:${line}\``);
|
|
return new vscode.Hover(md);
|
|
}
|
|
}
|
|
|
|
function relativePath(document: vscode.TextDocument, abs: string): string {
|
|
const root = vscode.workspace.getWorkspaceFolder(document.uri)?.uri.fsPath;
|
|
if (!root) return abs;
|
|
const rel = abs.toLowerCase().startsWith(root.toLowerCase())
|
|
? abs.slice(root.length + 1)
|
|
: abs;
|
|
return rel;
|
|
}
|