Skip to content

1.6.0: the fixes of the issue review of 2026-11-21 - #19

Merged
Sunrisepeak merged 23 commits into
mainfrom
fix/issue-review-2026-11-21
Nov 21, 2026
Merged

Sunrisepeak merged 23 commits into
mainfrom
fix/issue-review-2026-11-21

Conversation

@Sunrisepeak

@Sunrisepeak Sunrisepeak commented Nov 21, 2026 •

Copy link
Copy Markdown
Member

Summary

The fixes of the issue review of 2026-11-21, series 1.6.0, as the design record
.agents/docs/2026-11-21-editor-surfaces-and-feature-matrix.md (stream F) plans them: one pull request,
each fix a commit of its own. Addresses #13, #15, #16, #17 and #18; the parts that are not this
project's are listed under Triage.

Found in review and by the IDE runs, and fixed here:

  • CLion: an answer and the notifications after it run on one sequential thread, in the backend's order
    (a listener registered on an answer could miss the notification that followed it).
  • Backend: a dependency's features are every name mcpp registers (default, feature-deps, the target
    tables); suggestions bring their commas; an array left open is read on its own line; keys after the
    cursor are not offered again; app = { ... } under [targets] is not an unknown key (mcpp builds it).
  • Backend: a build database is used only while the manifest is the one it was read from. A graph asked
    within the watcher's 500 ms after a manifest change was the old manifest's; the real-IDE run met it
    about one run in two, on 1.5.0 too.
  • The IDE runs on macOS: actions invoked on the project's frame, an IDE started once the driver's
    ports are free; CLion 2026.1, whose JCEF is in its core, skips the run with the JCEF plugin disabled.

Triage

Criteria

Change Test Ran
inline tables tests/cts/rules.cpp: 0.9's goldens at every other position, golden/inline-tables.json, targeted cases local, Linux x86_64
features tests/e2e/protocol.cpp over a path and a workspace dependency; tests/cts/rules.cpp; tests/e2e/probe.cpp for capabilities/explain local
scope and level tests/e2e/protocol.cpp, checked against the protocol schema local
CLion threading BackendTest.theReadingThreadRunsNoListener; the real-IDE restart with mcpp.toml open unit local; IDE runs in CI
CLion JCEF UiTest.noClassOutsideUiJcefNamesJcef; GraphInteractionTest.graphExplainsAbsentJcefPlugin unit local; IDE runs in CI (Linux, macOS aarch64)
CLion strings, cache tab UiTest.aToolbarsTextIsReadWhenItIsShown, UiTest.theCacheInTheSectionsOfVsCodesPage; PackagedPluginTest unit local; IDE runs in CI
VS Code pairs test/toml/languageConfiguration.test.ts, the parity gate local (550 tests)
Neovim tests/smoke.lua local

Real IDEs: CI runs CLion 2026.1.5.2 and 2026.2.4.1 on Linux x86_64 and 2026.2.4.1 on macOS aarch64;
locally (Linux x86_64, Xvfb) CLion 2026.2.3 and 2026.2.4.1 passed PackagedPluginTest (33 checks, the
restart with mcpp.toml open and the cache sections included) and the three graph runs, and the VS Code
e2e suite passed in VS Code 1.91.0.

Local, Linux x86_64: mcpp build && mcpp test (14 passed), check-sources, check-i18n,
gen vscode with no diff, test_changes.sh, npm test, gradle test buildPlugin verifyPlugin
(Compatible with 2026.1 and 2026.2.3), the Neovim smoke test. The real-IDE runs and the e2e jobs are
left to CI.

Compatibility

  • Protocol 2 unchanged; commands/list adds scope and level to a cache command.
  • A new diagnostic, mcpp.manifest.unknownFeature, at the severity of mcpp.toml.diagnostics.unknownKey.
  • No setting is added or changed. VS Code's contributions of 0.9.0 are unchanged; mcpp-toml gains configuration.
  • CLion: 2026.1 and later, as before; the mcppls CLion plugin 0.23.0.

Checklist

  • One thing (the fixes of one review, each a commit); the title is X.Y.Z: <sentence>.
  • The protocol schema, docs (docs/rules.md, the CLion README), spec/i18n and CHANGELOG.md follow the behaviour.
  • spec/ is edited, not its output; mcpp-ide-dev gen vscode leaves no diff.
  • No commit carries an attribution trailer.

commands/list gives each cleanup the scope of its plan (project for the
project's build, shared for the shared cache) and its danger level, so a
view places a cleanup beside what it acts on and invents no grouping of its
own (design 2026-11-21, F4; #13).
Inside `app = { ... }` under [targets] the rules layer offers the keys of
[targets.app], less those the inline table has, and an enum key's values;
a dependency's inline table is its specification, whose keys the schema
does not list, and gets nothing. A key is offered only after `{` or `,`.
The new answers are where mcpp-vscode 0.9 answered nothing; they are kept
in golden/inline-tables.json, apart from 0.9's goldens, which every other
position still equals (design 2026-11-21, F6; #15).
Inside a dependency's `features = [...]` the rules layer offers the
features its own manifest declares and the edge does not name yet, a hover
names the dependency, the default and what a feature implies, and a name the
manifest does not declare is mcpp.manifest.unknownFeature, at the severity of
unknownKey. The manifest is the one `path` names, or for workspace = true the
one the nearest workspace's [workspace.dependencies] names; a dependency
that declares no [features] accepts any name, as mcpp does. An index
package's features are not answered: mcpp states none, and
capabilities/explain names mcpp#992, which asks for them (design
2026-11-21, F7; #16, #17).
…th #

The mcpp-toml language had no configuration, so VS Code paired nothing
in mcpp.toml and Toggle Line Comment did nothing. It gets one: [ ] and { }
as brackets, quotes that close outside a string or a comment, # as the line
comment. The parity gate keeps every field of each language 0.9.0
contributed and admits an added one (design 2026-11-21, F8; #15, #18).
"Read access is allowed from inside read-action only" was logged at
startup and each time a backend started: McppDocuments.reopen() read the
open documents from the startup activity and from the thread that reads the
backend's output, where every listener ran. That thread now only decodes
frames: notifications reach their listeners in order on one pooled thread,
answers complete on the pool, and reopen() takes its snapshot of the open
documents in a read action (design 2026-11-21, F1; #13).
Opening a graph without the JCEF plugin failed with NoClassDefFoundError:
the dependency on com.intellij.modules.jcef is optional, but JcefPage, a
class of the core, linked to JCEF's classes, and its guard,
JBCefApp.isSupported(), was the call that failed. The core now knows a page
host (ui/PageHost.kt); JCEF's (ui/jcef) is registered only by mcpp-jcef.xml,
which the platform reads when the JCEF plugin is loaded. Without a host,
or with JCEF switched off, the tab says why (design 2026-11-21, F2; #13).
…ad when shown

The cache tab drew every cleanup as one identical icon in its toolbar, with
no grouping. It now has the two sections of VS Code's page, Project cache
(target/) and Global build cache, each with its cleanups as links on its row
and in its context menu, placed by the scope commands/list states; an
ellipsis marks one that asks first, and the toolbar keeps Refresh. Two
commands of one plan are one action. Toolbar texts and the Libraries button
are read when shown, since the views are built before the session's strings
arrive: the English tooltip beside Chinese rows. A test holds JCEF's
classes to ui/jcef (design 2026-11-21, F3 and F5; #13).
The real-IDE runs already fail on an error the IDE logs, but none reached
the paths of #13. PackagedPluginTest restarts the backend with mcpp.toml
open and checks that the document is sent again, and checks the cache tab's
sections. GraphInteractionTest runs with the JCEF plugin disabled beside the
run with JCEF switched off. A job runs the startup chain and the graphs on
macOS aarch64, where the report came from, and a weekly run checks the
latest published plugin on the stable CLions (design 2026-11-21, F0).
:Mcpp showCachePanel shows the two sections CLion's cache tab and VS Code's
page have, Project cache (target/) and Global build cache, each with the
subcommands of its cleanups, placed by the scope commands/list states, one
per plan (design 2026-11-21, "The cache view"; #13).
…elog

Every component is 1.6.0. The CLion plugin depends on mcppls's CLion plugin
0.23.0, its latest release. CHANGELOG.md lists the fixes of the review of
2026-11-21; the CLion README names the runs added (design 2026-11-21, F9).
The record of the issue review of 2026-11-21: the surfaces a feature reaches
a user by, the feature matrix every plugin is held to, Zed and Helix, the
fixes of #13, #15 to #18 as one pull request per repository, and the plan
of the work. Stream F is implemented here; its last section states where the
implementation differs. Local reviews stay out of the repository
(.agents/reviews/).
…iew's cases

The features of a dependency are every name mcpp registers: the keys of
[features], default among them, and the names of [feature-deps.<name>] and,
under a target selector, of feature-deps, feature-requires-abi and
feature-xlings; an empty [features] declares none, so any name is accepted,
as mcpp does. A suggestion between two elements brings its commas, an array
left open is read on its own line only, a multi-line element is not
reported, and one answer reads each manifest once. Inside an inline table the
keys written after the cursor are not offered again, and app = { ... } under
[targets] or [profile] is not an unknown key: mcpp reads it as [targets.app].
capabilities/explain says that mcpp states no features of an index package,
without naming a capability no release has.
…s order

With answers completed on the pool and notifications on their own thread, a
listener registered when an answer arrived (a job's end, a new project) could
miss the notification that followed it, and a run's buffered output could be
replayed after later lines. Both now run on one sequential thread, in the
order the backend wrote them. The page's explanation is set on the EDT, a
browser whose query cannot be made is disposed, and the weekly run reads the
newest published release that carries the plugin.
CLion 2026.1 carries JCEF in its core (lib/intellij.libraries.jcef.jar), so
no installation of it lacks JCEF and the run with the plugin disabled is
skipped there, saying why; 2026.2 has the plugin, built per system, and the
run holds on Linux x86_64 and macOS aarch64. The macOS job keeps the JUnit
results, which name a failed assertion's message.
…he project's frame

On macOS aarch64 the driver's mcpp.build was refused as disabled: the
action is enabled for a session that knows the project's root, and the
driver reads the data context of the focused window, which a macOS runner
need not give the IDE. The run waits for the root and invokes the action on
the project's frame, and a refusal names the root, the commands and the
frame.
…s frame

The build now ran on macOS aarch64, and the next action, a graph, was refused
the same way: the driver read the focused window's data context. Each action
of the run goes to the project's frame.
… one it was read from

The kept build database was dropped when the watcher next polled the
manifest (every 500 ms), so a graph asked within that time was the old
manifest's, and the page, which is not redrawn on manifest/changed, kept
it. The real-IDE graph run met it about one time in two, on 1.5.0 as on
this series. An entry now records the manifest's time from before mcpp read
it and is used only while the manifest has that time.
On macOS aarch64 one of the three graph runs, never the same one, started an
IDE whose driver never connected; each followed another IDE's run, and the
driver reaches every IDE on the same fixed ports. A run now starts when they
are free, and the macOS job keeps the IDE's log.
On macOS aarch64 the second or the third IDE started on one runner could stop
at its start, before any plugin loads (its log ends at "CPU cores"), and its
driver never connected; which run met it changed from one run to the next.
Each of the three graph runs now has its runner.
…logs

The graph run on Linux x86_64 passed its seven checks and then failed on an
error the IDE logged, which only the packaged-plugin run kept; neither the
graph nor the settings run said what it was. Each now records the error's
types and frames (no message, no path) before it fails, and both jobs keep
them.
On macOS aarch64 an IDE stopped at its start one run in three, on a runner
of its own too: its log ends at "CPU cores", before any plugin loads, and
its driver never connected. Such a run starts a new IDE once and records
that it did; a run whose IDE started is never repeated. The macOS job keeps
the IDE's thread dumps for the stop itself.
@Sunrisepeak
Sunrisepeak merged commit 9ec5773 into main Nov 21, 2026
35 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant