The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
test(plugins): freeze plugin API 1.0.0
l0ng-ai3ef247c55fcb
diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/events.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/events.witnew file mode 100644index 000000000..2d118d812--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/events.wit@@ -0,0 +1,54 @@+package openidea:[email protected];++/// Workbench events, delivered in batches to `event-handler.handle`.+interface events {+ use types.{error, extension};++ record action-performed {+ /// Action id (`editor.duplicate-line`).+ action: string,+ title: string,+ /// How the user started it: `keyboard`, `menu`, `toolbar`,+ /// `context-menu`, `search` or `other` (more may be added).+ source: string,+ /// Its keyboard shortcut, when it has one (`Ctrl+D`).+ shortcut: option<string>,+ }++ variant event {+ file-opened(string),+ file-saved(string),+ editor-focused(option<string>),+ action-performed(action-performed),+ vcs-changed(string),+ scheduled,+ /// A kind added after 1.0 (subscribed to by its name).+ other(extension),+ }++ /// Delivers `kind` events from now on, for the rest of the session (also+ /// across idle reclaim: an event activates the plugin again). Declare+ /// `activation = ["on-event:<kind>"]` to get them before first use.+ /// Kinds: `file-opened`, `file-saved`, `editor-focused` (the focused editor+ /// changed), `vcs-changed` (a repository's state changed: commit,+ /// checkout, fetch…), `action-performed` (an IDE action ran) and+ /// `scheduled` (the `on-schedule` period elapsed); later IDEs add more,+ /// and an IDE that doesn't know one fails with `invalid`.+ /// Requires `events` (`events.input` for `action-performed`).+ subscribe: func(kind: string) -> result<_, error>;+ unsubscribe: func(kind: string);+}++/// Long-running work with a progress indicator. While a task is open, the+/// call that began it may run for the background budget (60 s) instead of 5 s.+interface tasks {+ resource task {+ /// `done` of `total` units (`none`: indeterminate), with a short status.+ report: func(done: u32, total: option<u32>, message: option<string>);+ /// The user cancelled it: stop soon and return.+ is-cancelled: func() -> bool;+ }++ /// Starts a task shown in the status bar; dropping it ends it.+ begin: func(title: string, cancellable: bool) -> task;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/exports.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/exports.witnew file mode 100644index 000000000..065ef9a5f--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/exports.wit@@ -0,0 +1,75 @@+package openidea:[email protected];++interface lifecycle {+ use types.{context, error};++ /// Called once after the instance is created: subscribe to events and+ /// restore state from `storage`. Contributions (commands, languages,+ /// themes, …) are declared in plugin.toml, not registered here.+ /// An error fails the activation (shown on the plugin's page).+ activate: func(ctx: context) -> result<_, error>;+ /// Called before the instance is dropped (disable, uninstall, idle reclaim).+ deactivate: func();+}++interface commands {+ use types.{error};+ use invocation.{invocation};++ /// Runs one of the plugin's commands. Returns an optional message.+ /// `cancelled` (the user gave up) and `denied` (a capability is missing)+ /// are not counted as the plugin failing.+ run: func(id: string, ctx: borrow<invocation>, arg: option<string>) -> result<option<string>, error>;+}++interface event-handler {+ use events.{event};+ use invocation.{invocation};++ /// A batch of subscribed events, oldest first, from one window (`ctx`).+ handle: func(events: list<event>, ctx: borrow<invocation>);+}++/// Optional export (world `plugin-syntax`): syntax of the plugin's own+/// languages, for languages the IDE has no grammar for. The IDE calls it+/// with the whole document; results are flat. Offsets are UTF-8 byte offsets+/// into `text` (the IDE converts them); lines are 0-based.+interface syntax-provider {+ /// One highlighted range. `kind` is a highlight category: keyword, string,+ /// string-special, escape, regexp, atom, number, constant, comment,+ /// doc-comment, function, function-call, builtin, type, namespace,+ /// variable, self-variable, property, attribute, macro, label, tag,+ /// operator, punctuation. Unknown kinds are ignored; ranges must be+ /// sorted and not overlap.+ record token {+ start: u32,+ end: u32,+ kind: string,+ }++ /// A symbol of the structure view. `parent` is the index of the enclosing+ /// symbol in the same list (which must come first).+ record symbol {+ name: string,+ detail: option<string>,+ /// class, interface, struct, enum, function, method, constructor,+ /// field, property, variable, constant, module, namespace, event, …+ kind: string,+ start: u32,+ end: u32,+ name-start: u32,+ name-end: u32,+ parent: option<u32>,+ }++ /// A foldable line range. `kind`: region, comment or imports.+ record fold {+ start-line: u32,+ end-line: u32,+ kind: string,+ }++ highlights: func(language: string, text: string) -> list<token>;+ outline: func(language: string, text: string) -> list<symbol>;+ folding: func(language: string, text: string) -> list<fold>;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/host.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/host.witnew file mode 100644index 000000000..b6325cb71--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/host.wit@@ -0,0 +1,38 @@+package openidea:[email protected];++/// Writes to the IDE log, tagged with the plugin id.+interface log {+ use types.{log-level};++ log: func(level: log-level, message: string);+}++interface ui {+ use types.{notification-level};++ record status-item {+ text: string,+ tooltip: option<string>,+ /// One of the plugin's commands, run when the item is clicked.+ command: option<string>,+ }++ /// Shows a notification balloon in the window the current command or+ /// event came from (every window when there is none).+ show-notification: func(level: notification-level, title: string, body: string);+ /// Shows or updates the plugin's status bar item `id` in every window.+ set-status-item: func(id: string, item: status-item);+ remove-status-item: func(id: string);+}++/// Persistent key-value storage of the plugin (survives restarts and idle+/// reclaim; instance memory does not). Requires `storage`. At most 1 MiB.+interface storage {+ use types.{error};++ get: func(key: string) -> result<option<string>, error>;+ set: func(key: string, value: string) -> result<_, error>;+ delete: func(key: string) -> result<_, error>;+ /// Keys starting with `prefix`, sorted.+ keys: func(prefix: string) -> result<list<string>, error>;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/io.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/io.witnew file mode 100644index 000000000..f1fe634a3--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/io.wit@@ -0,0 +1,96 @@+package openidea:[email protected];++/// Problems in files, shown in the editor and the Problems view.+interface diagnostics {+ use types.{error, range, location};++ enum severity {+ error,+ warning,+ info,+ hint,+ }++ /// Another place that explains a diagnostic (the earlier declaration, say).+ record related-information {+ location: location,+ message: string,+ }++ record diagnostic {+ range: range,+ severity: severity,+ message: string,+ /// Rule or check id (`LineLength`).+ code: option<string>,+ /// The tool that found it, when not the plugin itself (`checkstyle`).+ source: option<string>,+ /// `unnecessary` (shown faded) and `deprecated` (struck through); unknown ones are ignored.+ tags: list<string>,+ related: list<related-information>,+ }++ /// Replaces the plugin's diagnostics for the file at `path` (absolute, in+ /// an open project); an empty list clears them. Requires `project.read`.+ publish: func(path: string, diagnostics: list<diagnostic>) -> result<_, error>;+}++/// HTTP(S) to the hosts granted with `net:<host>`.+interface net {+ use types.{error};++ record header {+ name: string,+ value: string,+ }++ record request {+ method: string,+ /// `https://…`; plain `http://` only to `localhost` / `127.0.0.1`.+ url: string,+ /// `{{secret:<name>}}` in a value is replaced by the plugin's secret+ /// `name` on the way out (requires `secrets`); the plugin never sees it.+ headers: list<header>,+ body: option<list<u8>>,+ /// Default 30 s; the call's own budget applies too.+ timeout-ms: option<u32>,+ }++ record response {+ status: u16,+ headers: list<header>,+ /// At most 8 MiB.+ body: list<u8>,+ }++ /// Fails with `denied` for a host the plugin may not reach, `cancelled`+ /// when a newer request replaced the call or the user cancelled.+ fetch: func(req: request) -> result<response, error>;+}++/// Secrets the user stored for the plugin (Settings › Plugins, kept in the+/// OS keychain). Plugins only use them through `{{secret:<name>}}` in+/// `net` requests. Requires `secrets`.+interface secrets {+ is-set: func(name: string) -> bool;+}++/// One-off runs of programs granted with `process:<program>` (the file the+/// user approved, checked before every run).+interface process {+ use types.{error};+ use workspace.{project};++ record output {+ /// `none` when killed by a signal.+ status: option<s32>,+ /// At most 4 MiB each (the rest is dropped).+ stdout: string,+ stderr: string,+ }++ /// Runs `program` with `args` in `cwd`'s root (else the plugin's data+ /// directory) and waits; cancelled with the task or call. Call it inside+ /// a task for anything slow.+ run: func(program: string, args: list<string>, cwd: option<borrow<project>>, stdin: option<string>) -> result<output, error>;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/plugin.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/plugin.witnew file mode 100644index 000000000..938ee0842--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/plugin.wit@@ -0,0 +1,67 @@+/// OpenIDEA plugin API, version 1.0. Once released, 1.x only adds (new+/// interfaces, new optional exports; plugins/README.md, "Evolving the plugin+/// API"); a 2.0 keeps 1.0 running through an adapter in the host.+///+/// A plugin is a WebAssembly component targeting the `plugin` world (or+/// `plugin-syntax`). It runs sandboxed: no filesystem, network, environment+/// or processes beyond WASI's clocks and randomness; everything else goes+/// through the imports below, gated by the capabilities granted in+/// `plugin.toml` (a missing one returns `error::denied`).+package openidea:[email protected];++world plugin {+ import log;+ import ui;+ import storage;+ import workspace;+ import editor;+ import invocation;+ import vcs;+ import events;+ import tasks;+ import diagnostics;+ import net;+ import secrets;+ import process;+ import views;+ import settings;++ export lifecycle;+ export commands;+ export event-handler;+}++/// A plugin that also provides syntax for its languages.+world plugin-syntax {+ include plugin;+ export syntax-provider;+}++/// A plugin with editor providers (`[[contributes.providers]]`).+world plugin-providers {+ include plugin;+ export providers;+}++/// A plugin with views or custom editors (`[[contributes.views]]`,+/// `[[contributes.custom-editors]]`).+world plugin-views {+ include plugin;+ export view-provider;+}++/// Only the `syntax-provider` export: guests generate it next to `plugin`+/// (the component tools merge both into one component).+world syntax {+ export syntax-provider;+}++/// Only the `providers` export, generated next to `plugin` like `syntax`.+world editor-providers {+ export providers;+}++/// Only the `view-provider` export, generated next to `plugin` like `syntax`.+world views-provider {+ export view-provider;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/providers.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/providers.witnew file mode 100644index 000000000..97dd4c7a6--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/providers.wit@@ -0,0 +1,81 @@+package openidea:[email protected];++/// Editor features a plugin provides for the languages it declares under+/// `[[contributes.providers]]` (the host calls only declared kinds). They run+/// on the editing path: a result later than ~50 ms is dropped, a call still+/// running at 500 ms is interrupted.+interface providers {+ use types.{error, position, range, text-edit, location};++ /// The document a request is about.+ record document {+ path: string,+ language: string,+ version: u64,+ text: string,+ }++ record completion-item {+ label: string,+ detail: option<string>,+ /// Icon and sort group: text, method, function, constructor, field,+ /// variable, class, interface, module, property, unit, value, enum,+ /// keyword, snippet, color, file, reference, folder, enum-member,+ /// constant, struct, event, operator or type-parameter. Unknown kinds+ /// show no icon.+ kind: option<string>,+ /// With `snippet`, tab stops and placeholders (`$1`, `${1:name}`, `$0`).+ insert-text: string,+ snippet: bool,+ /// Replaced on accept; `none`: the word at the caret.+ replace: option<range>,+ sort-text: option<string>,+ /// Matched against what was typed instead of `label`.+ filter-text: option<string>,+ documentation: option<string>,+ /// Applied with the item elsewhere in the document (an import).+ additional-edits: list<text-edit>,+ }++ record inline-suggestion {+ insert-text: string,+ /// Replaced range; `none` inserts at the caret.+ replace: option<range>,+ }++ record file-edit {+ path: string,+ edits: list<text-edit>,+ }++ record code-action {+ title: string,+ /// `quickfix`, `refactor`, …+ kind: option<string>,+ preferred: bool,+ edits: list<file-edit>,+ /// The plugin's own reference: with it and no `edits`, the edits are+ /// computed by `resolve-code-action` once the user picks the action.+ data: option<string>,+ }++ record line-marker {+ line: u32,+ /// Gutter icon: `navigate` (default), `implemented`, `implementing`, `run`.+ icon: option<string>,+ tooltip: string,+ /// Opened on click.+ target: option<location>,+ }++ completion: func(doc: document, at: position, trigger: option<string>) -> list<completion-item>;+ /// Ghost text at the caret (typing replaces an older request: it is cancelled).+ inline-completion: func(doc: document, at: position) -> option<inline-suggestion>;+ /// Actions for `selection` (quick fixes for the plugin's own diagnostics).+ code-actions: func(doc: document, selection: range) -> list<code-action>;+ /// The edits of an action `code-actions` returned with `data`, when the+ /// user picks it (the command budget applies, not the editor's 50 ms).+ resolve-code-action: func(doc: document, action: code-action) -> result<code-action, error>;+ definition: func(doc: document, at: position) -> list<location>;+ line-markers: func(doc: document) -> list<line-marker>;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/types.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/types.witnew file mode 100644index 000000000..2e2b48f74--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/types.wit@@ -0,0 +1,73 @@+package openidea:[email protected];++/// Shared types. Positions are 0-based lines and UTF-16 code unit columns,+/// as in the editor and LSP.+interface types {+ /// Why a host call failed. A capability that is not granted is reported+ /// as `denied`, so the plugin can degrade (0.1 trapped instead).+ variant error {+ /// Not granted; the payload names the capability (`editor.write`).+ denied(string),+ /// The document changed since the version the edit was made for.+ stale,+ not-found(string),+ invalid(string),+ /// Cancelled by the user, or the plugin is being stopped.+ cancelled,+ failed(string),+ }++ enum log-level {+ trace,+ debug,+ info,+ warn,+ error,+ }++ enum notification-level {+ info,+ warning,+ error,+ }++ record position {+ line: u32,+ character: u32,+ }++ record range {+ start: position,+ end: position,+ }++ record text-edit {+ range: range,+ text: string,+ }++ /// A range in a file (absolute path).+ record location {+ path: string,+ range: range,+ }++ /// A case added after 1.0, carried by the `other` case of a variant that+ /// grows (events, view bodies, view events, form fields): its kind and its+ /// data as JSON. Whoever doesn't know the kind ignores it or shows a+ /// fallback; the SDKs decode the kinds they know.+ record extension {+ kind: string,+ data: string,+ }++ /// Passed to `lifecycle.activate`.+ record context {+ plugin-id: string,+ plugin-version: string,+ /// Version of this API the host implements, e.g. "1.0".+ api-version: string,+ /// Capabilities granted to the plugin (`editor.write`, `process:git`, …).+ capabilities: list<string>,+ }+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/views.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/views.witnew file mode 100644index 000000000..dcc806dcb--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/views.wit@@ -0,0 +1,154 @@+package openidea:[email protected];++/// Declarative views: tool windows declared+/// under `[[contributes.views]]` and custom editors under+/// `[[contributes.customEditors]]`. The plugin describes what to show; the+/// IDE renders it with its own components (theme, keyboard, accessibility)+/// and sends the user's actions back as `view-event`s. Nothing of the plugin+/// runs in the WebView, except a `html` body, which is shown in a sandboxed+/// frame that can only exchange messages with the plugin.+interface view-types {+ use types.{extension};++ record button {+ id: string,+ label: string,+ /// An IDE icon name (`refresh`, `add`, `remove`, `run`, …).+ icon: option<string>,+ enabled: bool,+ }++ /// A tree node; `parent` is the key of an earlier item (none: a root).+ record tree-item {+ key: string,+ parent: option<string>,+ label: string,+ icon: option<string>,+ /// Grey text after the label.+ detail: option<string>,+ /// Shows an expander even before its children are known+ /// (`expand` asks for them).+ expandable: bool,+ expanded: bool,+ }++ record list-item {+ key: string,+ label: string,+ icon: option<string>,+ detail: option<string>,+ }++ variant field-value {+ text(string),+ multiline(string),+ checkbox(bool),+ /// The options and the chosen one.+ choice(tuple<list<string>, string>),+ /// A field type added after 1.0 (an IDE that doesn't know it leaves it out).+ other(extension),+ }++ record field {+ key: string,+ label: string,+ value: field-value,+ }++ /// Rows `first-row`..`first-row + len(rows)` of `total-rows`: the IDE+ /// asks for the rows it shows (`viewport`), so large tables stay cheap.+ record table {+ columns: list<string>,+ total-rows: u32,+ first-row: u32,+ rows: list<list<string>>,+ editable: bool,+ }++ variant body {+ /// A centred message (empty state, errors).+ message(string),+ tree(list<tree-item>),+ %list(list<list-item>),+ form(list<field>),+ table(table),+ /// HTML shown in a sandboxed frame: no scripts from elsewhere, no+ /// network, no IDE API. Its script talks to the plugin with+ /// `openidea.postMessage(text)` / `openidea.onMessage(fn)`.+ html(string),+ /// A body added after 1.0; an IDE that doesn't know it says it needs updating.+ other(extension),+ }++ record view {+ toolbar: list<button>,+ body: body,+ /// A line below the body (counts, last refresh…).+ status: option<string>,+ }++ /// The table rows the IDE shows.+ record viewport {+ first-row: u32,+ rows: u32,+ }++ record cell-edit {+ row: u32,+ column: u32,+ value: string,+ }++ variant view-event {+ /// A toolbar button.+ button(string),+ /// Double click / Enter on a tree or list item.+ activate(string),+ select(string),+ expand(string),+ collapse(string),+ /// A form field changed: key and new value (`true`/`false` for checkboxes).+ field(tuple<string, string>),+ cell(cell-edit),+ /// Insert an empty row before this one (the row count: append).+ insert-row(u32),+ delete-rows(list<u32>),+ /// From the `html` body's script.+ message(string),+ /// An event added after 1.0, from a body or field added after 1.0.+ other(extension),+ }+}++/// What a plugin's code can ask of its views.+interface views {+ use types.{error};++ /// The view (or every custom editor of that id) shows outdated content:+ /// the IDE renders it again.+ refresh: func(view: string);+ /// Sends a message to the script of a view's `html` body.+ post-message: func(view: string, message: string) -> result<_, error>;+ /// Opens a terminal tab in the window the call came from, running+ /// `program` (pinned by a `process:<program>` grant) with `args` in the+ /// project root: long-running output (logs) and interactive sessions.+ open-terminal: func(title: string, program: string, args: list<string>) -> result<_, error>;+}++/// The plugin's own settings (`[contributes.settings]`), as the user set them+/// (project over global) or the schema's default.+interface settings {+ /// The value of `key` as JSON (`true`, `3`, `"text"`), none if unknown.+ get: func(key: string) -> option<string>;+}++/// Optional export (world `plugin-views`): content of declared views and+/// custom editors. For a custom editor, `ctx.editor()` is its document.+interface view-provider {+ use view-types.{view, viewport, view-event};+ use invocation.{invocation};+ use types.{error};++ render: func(view: string, viewport: option<viewport>, ctx: borrow<invocation>) -> result<view, error>;+ handle: func(view: string, event: view-event, ctx: borrow<invocation>) -> result<_, error>;+}diff --git a/sdk/rust/openidea-plugin/tests/api/1.0.0/workspace.wit b/sdk/rust/openidea-plugin/tests/api/1.0.0/workspace.witnew file mode 100644index 000000000..febca7c6f--- /dev/null+++ b/sdk/rust/openidea-plugin/tests/api/1.0.0/workspace.wit@@ -0,0 +1,90 @@+package openidea:[email protected];++interface workspace {+ use types.{error};++ /// A project open in the IDE.+ resource project {+ /// Absolute path of the project root. Requires `project.read`.+ root: func() -> result<string, error>;+ /// Reads a UTF-8 text file inside the project (absolute, or relative+ /// to the root); paths leaving the root are refused. Unsaved editor+ /// contents win over the disk. Requires `project.read`.+ read-file: func(path: string) -> result<string, error>;+ /// Project files whose root-relative path matches `glob` (`**/*Mapper.xml`),+ /// at most `limit`, as absolute paths. Ignored and excluded files are+ /// skipped. Requires `project.read`.+ find-files: func(glob: string, limit: u32) -> result<list<string>, error>;+ }++ /// Projects open in any window. Requires `project.read`.+ projects: func() -> result<list<project>, error>;+}++interface editor {+ use types.{error, range, text-edit};++ record document {+ /// Grows with every change; edits name the version they were made for.+ version: u64,+ text: string,+ }++ /// A file open in an editor.+ resource text-editor {+ /// Absolute path of the file.+ path: func() -> string;+ /// Language id (`rust`, `solidity`, …).+ language: func() -> string;+ /// Current version and text. Requires `editor.read`.+ document: func() -> result<document, error>;+ /// Selections when the command was invoked (a cursor is an empty+ /// range). Requires `editor.read`.+ selections: func() -> result<list<range>, error>;+ /// Applies `edits` as one undoable change, only if the document is+ /// still at `version` (else `stale`, and nothing changes). Ranges are+ /// in that version and must not overlap. Returns the new version.+ /// Requires `editor.write`.+ apply-edits: func(version: u64, edits: list<text-edit>) -> result<u64, error>;+ }+}++/// Where a command or event comes from.+interface invocation {+ use workspace.{project};+ use editor.{text-editor};++ resource invocation {+ /// The window's project.+ project: func() -> option<project>;+ /// The window's focused editor.+ editor: func() -> option<text-editor>;+ }+}++/// Git, for the repository containing a project.+interface vcs {+ use types.{error};+ use workspace.{project};++ record repository-status {+ /// Absolute path of the working tree root.+ root: string,+ /// `none` when HEAD is detached.+ branch: option<string>,+ commit: option<string>,+ upstream: option<string>,+ ahead: u32,+ behind: u32,+ /// Merge / rebase / cherry-pick in progress.+ operation: option<string>,+ /// Files with staged or unstaged changes.+ changed-files: u32,+ }++ /// `none` when the project is not in a repository. Requires `vcs.read`.+ status: func(project: borrow<project>) -> result<option<repository-status>, error>;+ /// Fetches all remotes (pruning deleted branches). Requires `vcs.write`.+ /// Long-running: call it inside a task.+ fetch: func(project: borrow<project>) -> result<_, error>;+}diff --git a/sdk/rust/openidea-plugin/tests/api_frozen.rs b/sdk/rust/openidea-plugin/tests/api_frozen.rsindex e6723b428..b5a0e08ca 100644--- a/sdk/rust/openidea-plugin/tests/api_frozen.rs+++ b/sdk/rust/openidea-plugin/tests/api_frozen.rs@@ -140,12 +140,18 @@ fn released_apis_are_unchanged() {for (key, was) in &release {match current.get(key) {None => broken.push(format!("{key}: removed (was {was})")),- // A world may gain imports and exports; everything else stays as it was.+ // A world may gain imports and exports; everything else stays as it was. Items are+ // compared without their `@version`: a later minor names them `@1.1.0`, and wasmtime+ // resolves the release's `@1.0.0` to it.Some(now) if key.starts_with("world ") => {let had = |s: &str, part: &str| -> Vec<String> {let start = s.find(part).unwrap() + part.len();let end = s[start..].find(']').unwrap() + start;- s[start..end].split(", ").filter(|x| !x.is_empty()).map(str::to_owned).collect()+ s[start..end]+ .split(", ")+ .filter(|x| !x.is_empty())+ .map(|x| x.split('@').next().unwrap_or(x).to_owned())+ .collect()};for part in ["imports [", "exports ["] {let now = had(now, part);