Merge upstream (263 base)

.agents/skills/INDEX.md

@@ -21,11 +21,11 @@ One row per skill in this directory. `SKILL.md` holds the full instructions.
 | [icons](icons/SKILL.md) | Create or review IntelliJ New UI SVG icons and theme variants. |
 | [ide-diagnostics-mcp](ide-diagnostics-mcp/SKILL.md) | Inspect a running IntelliJ IDE for freezes or blocked threads via MCP. |
 | [jewel-markdown](jewel-markdown/SKILL.md) | Build or debug Jewel Markdown parsing, rendering, and styling. |
-| [jewel-pr-preparer](jewel-pr-preparer/SKILL.md) | Prepare a Jewel pull request: validate the commit, run local CI checks, draft release notes, and create the PR. |
-| [jewel-release-helper](jewel-release-helper/SKILL.md) | Prepare a Jewel release: version bumps, checks, release notes, cherry-picks, artifact validation, and tagging. |
+| [jewel-release](jewel-release/SKILL.md) | Prepare a Jewel PR or release: checks, release notes, cherry-picks, tagging. |
 | [jna](jna/SKILL.md) | Implement or debug JNA bindings and ABI layouts in Kotlin or Java. |
 | [kotlin-ui-dsl](kotlin-ui-dsl/SKILL.md) | Write IntelliJ dialogs and settings with Kotlin UI DSL v2 panels. |
 | [kotlin-ui-swing-component-architecture](kotlin-ui-swing-component-architecture/SKILL.md) | Design IntelliJ Swing UI components, state flow, and EDT work. |
+| [modcommand-migration](modcommand-migration/SKILL.md) | Convert LocalQuickFix or IntentionAction to the ModCommand API. |
 | [module-dependencies](module-dependencies/SKILL.md) | Add or modify IntelliJ module dependencies in `.iml` files. |
 | [module-set-pluginization](module-set-pluginization/SKILL.md) | Convert Product DSL module sets into bundled wrapper plugins. |
 | [notebook-for-experiment](notebook-for-experiment/SKILL.md) | Create reproducible Jupyter notebooks for performance experiments. |
@@ -34,13 +34,16 @@ One row per skill in this directory. `SKILL.md` holds the full instructions.
 | [poly-context](poly-context/SKILL.md) | Implement PolyContext feature gating and environment detection. |
 | [poly-symbols](poly-symbols/SKILL.md) | Implement PolySymbols completion, references, and rename. |
 | [pseudo-kmp](pseudo-kmp/SKILL.md) | Create or modify IntelliJ pseudo-KMP expect/actual modules. |
+| [py-code-insight-counters](py-code-insight-counters/SKILL.md) | Count Python code insight work in tests with PyCodeInsightCounters. |
 | [registry](registry/SKILL.md) | Use the IntelliJ Registry API for registry keys and feature flags. |
+| [rust-code-style](rust-code-style/SKILL.md) | Write or review Rust in the build tools: errors, CLI grammar, crates, tests, lint, format and Bazel. |
 | [safe-push](safe-push/SKILL.md) | Push IntelliJ repository changes through the Safe Push workflow. |
+| [sibling-checkout-commits](sibling-checkout-commits/SKILL.md) | Take commits from a sibling checkout as patches, without a fetch. |
 | [ssr](ssr/SKILL.md) | Create or modify IntelliJ Structural Search and Replace patterns. |
 | [symbols-api](symbols-api/SKILL.md) | Use IntelliJ Symbol API for declarations, references, and rename. |
 | [testing](testing/SKILL.md) | Run or troubleshoot IntelliJ `tests.cmd` tests and discovery. |
 | [testing-internals](testing-internals/SKILL.md) | Debug IntelliJ `tests.cmd` execution, discovery, and runner internals. |
 | [treehouse](treehouse/SKILL.md) | Safely acquire, inspect, and return leased Treehouse workspaces. |
 | [ui-accessibility](ui-accessibility/SKILL.md) | Review IntelliJ UI accessibility for keyboard, focus, and labels. |
 | [writing-tests](writing-tests/SKILL.md) | Write IntelliJ JUnit 5 tests with fixtures, lifecycle, and EDT. |
-| [youtrack-community](youtrack-community/SKILL.md) | Use this bundled CLI only in community checkouts; monorepo users must use the monorepo-only `youtrack` skill instead. |
+| [youtrack-community](youtrack-community/SKILL.md) | YouTrack CLI for a community checkout; the monorepo uses `youtrack`. |

.agents/skills/bazel-test-migration/SKILL.md

@@ -45,7 +45,7 @@ For a community-only module in a standalone community checkout, run the same pac
 ```
 
 - Preserve required test attributes such as `tags`, `timeout`, `env`, `jvm_flags`, and `data`.
-- Add a module to `COMMUNITY_AGGREGATOR_BAZEL_MIGRATED_MODULES` only after the target is fully migrated and verified.
+- Add a module to `community/build/bazel-migrated-test-modules.txt` only after the target is fully migrated and verified. The community JPS aggregator then skips the module, and `tests.cmd` refuses it. The file documents its format.
 - Do not use `copy_file` to patch missing jars or descriptors into runfiles. Prefer normal `.iml` dependencies, target runtime/data dependencies, or the existing shared mechanism for that class of test.
 
 ## Dependency Decisions

.agents/skills/code-style/SKILL.md

@@ -9,14 +9,22 @@ Follow the IntelliJ Coding Guidelines with these IntelliJ-specific rules.
 
 ## Language
 
-- **ALWAYS use Kotlin for new files** - Only use Java when modifying existing Java code
+- Use Kotlin for new files unless the user explicitly requests Java.
+- Keep existing Java files in Java unless the task requires a language conversion.
+- Before writing or reviewing Java, read [Modern Java](references/modern-java.md).
 - Use idiomatic Kotlin: extension functions, data classes, null safety
 - Mark experimental APIs with `@ApiStatus.Experimental`
 - **Build scripts Kotlin style**: Follow `community/platform/build-scripts/kotlin-style-recommendations.md` for build-scripts code:
   - Use `@JvmField` for internal data class fields
   - Use `.put()`/`.get()` instead of `[]` operator
   - Use explicit `HashMap`/`HashSet`/`LinkedHashMap` instead of `mutableMapOf()`/`mutableSetOf()`
 
+## Sealed hierarchies
+
+- Before you list several subtypes in a `when` branch, an `is` check, or a `catch`, open the declaration of the type.
+- If a common supertype covers exactly those subtypes, use the supertype. It stays correct when someone adds a new subtype.
+- Check the value of a sealed type or an enum with an exhaustive `when`. Do not use an `is` check, an `as?` cast, an `==` comparison, or `else`. In Eel and IJent code, this is a rule, also for a `private` type. See `community/platform/eel/docs/api/exhaustive-when.md`.
+
 ## Formatting
 
 - Read every applicable `.editorconfig` before you review or change formatting.
@@ -25,3 +33,21 @@ Follow the IntelliJ Coding Guidelines with these IntelliJ-specific rules.
   - Line length: 140 characters max
   - Braces: `else`, `catch`, and `finally` on new lines
 - Only in `/rustrover` directory you must always use standard Kotlin formatting rules with 4 spaces indentation.
+
+## Error handling
+
+- In a `catch` block for `Throwable` or `Exception`, call `com.intellij.diagnostic.rethrowControlFlowException(e)` first.
+  It rethrows a control flow exception, such as `CancellationException`. A control flow exception must never reach the log.
+- Do not catch or rethrow `CancellationException` explicitly, and do not test the exception type by hand.
+- In Java, static-import `com.intellij.diagnostic.ControlFlowExceptionsKt.rethrowControlFlowException`.
+- Do not use the deprecated `com.intellij.openapi.diagnostic.rethrowControlFlowException`.
+
+```kotlin
+try {
+  doWork()
+}
+catch (e: Throwable) {
+  rethrowControlFlowException(e)
+  LOG.error(e)
+}
+```

.agents/skills/code-style/references/modern-java.LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ken Kousen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.agents/skills/code-style/references/modern-java.md

@@ -0,0 +1,228 @@
+# Modern Java
+
+Use modern Java for new and changed code within the target module's compatibility limits.
+Use nearby code to understand behavior, not as a reason to repeat outdated idioms.
+Keep unrelated code unchanged.
+
+## Compatibility
+
+- Check the module's effective language level and Java API target, including inherited build settings.
+- The installed JDK is not the compatibility target. Do not assume that every module supports Java 21.
+- Use stable features supported by that target.
+  Keep existing language levels and build settings unchanged unless the task requires an upgrade.
+- Do not enable preview features for a style change. Check the target release documentation before using features absent from the table.
+- Preserve public contracts, observable behavior, evaluation order, exception behavior, and null handling.
+
+## Features
+
+The table lists the first stable release for each feature, not its first preview.
+Check the [language release guide][language] and the target release's API documentation for other features.
+
+| Stable from | Prefer | Use when |
+| --- | --- | --- |
+| 9 | `List.of`, `Set.of`, `Map.of`, `Map.ofEntries`, `Map.entry` | Creating small unmodifiable collections. |
+| 10 | `var` | Declaring local variables, subject to the exceptions below. |
+| 10 | `List.copyOf`, `Set.copyOf`, `Map.copyOf` | Taking an unmodifiable snapshot. |
+| 14 | Switch expressions and arrow cases | Selecting a value or avoiding unnecessary fall-through. |
+| 15 | Text blocks | Representing multiline text without repeated escapes and concatenation. |
+| 16 | Records, including local records | Defining data carriers with value equality. |
+| 16 | Pattern matching for `instanceof` | Testing a type and then accessing the typed value. |
+| 17 | Sealed classes and interfaces | Modeling a deliberately closed hierarchy. |
+| 21 | Record patterns and pattern matching for `switch` | Deconstructing records or handling alternatives by type. |
+| 21 | Sequenced collections | Accessing first or last elements, or reversed views, in encounter order. |
+| 22 | Unnamed variables and patterns (`_`) | Declaring a value or matching a component that is deliberately unused. |
+| 25 | Flexible constructor bodies | Validating or preparing arguments before `super(...)` or `this(...)`. |
+
+### Local variables
+
+Default to `var` where supported.
+Use an explicit type when Java requires it, when it preserves semantics, or when it materially improves readability.
+Check generic inference, primitive widths, overload selection, and later assignments before replacing a declared type.
+Keep explicit types in fields, parameters, and return declarations.
+
+### Data and control flow
+
+- Prefer records for new value carriers.
+  For existing classes, first check accessors, equality, serialization, reflection, and inheritance requirements.
+- Records do not make referenced objects immutable. Preserve defensive copies where required.
+- Seal a hierarchy only when its extension contract permits it. Do not close an existing public extension point for style.
+- Prefer exhaustive switches over closed alternatives. Preserve deliberate fall-through and existing behavior for `null`.
+- Use record patterns where deconstruction makes the code clearer. Keep a named value when the code needs the whole record.
+- Use `_` only when the value is unused. Keep required validation, side effects, and error handling.
+- For `MethodHandle.invokeExact`, preserve the static argument types and the return cast, even when the result is unused.
+  A standalone invocation has the return type `void`, which can cause `WrongMethodTypeException`.
+- Preserve the exact whitespace and trailing newline when replacing string literals with text blocks.
+- Use flexible constructor bodies only where supported. Follow their restrictions on access to the instance under construction.
+
+### Collections
+
+Check the [collection guide][collections] and the [List API][list-api] before replacing a collection idiom.
+
+- Factory methods and `copyOf` produce unmodifiable collections. Keep a mutable implementation when callers need mutation.
+- These factories reject null elements, keys, or values. `Set.of` rejects duplicate elements, and map factories reject duplicate keys.
+- `Set.of` and `Map.of` do not preserve insertion order. Keep an ordered implementation when iteration order matters.
+- A snapshot differs from an unmodifiable view of a mutable collection. Preserve whether later source changes remain visible.
+- Unmodifiable collections do not make their elements immutable.
+- Check empty-collection behavior before replacing indexed access with `getFirst()` or `getLast()`.
+- A `reversed()` result is a view, not an independent copy. Preserve the required relationship to the source collection.
+
+### Concurrency
+
+Virtual threads are not a general replacement for IntelliJ executors or coroutines.
+Keep platform threading APIs, EDT requirements, read/write locks, cancellation, and lifecycle ownership.
+Before changing coroutine scope ownership, read the [coroutine scope rules](../../platform-coroutines-structured-concurrency/SKILL.md).
+Use virtual threads only when the target supports them and the task's concurrency design requires them.
+
+## Examples
+
+Apply each example only when the target supports it and the behavior checks above hold.
+
+### Generic inference
+
+Before:
+
+```text
+List<String> names = new ArrayList<>();
+```
+
+Prefer:
+
+```java
+var names = new ArrayList<String>();
+```
+
+Using `var names = new ArrayList<>();` instead infers `ArrayList<Object>` and loses the element type.
+Keep constructor type arguments only when inference would otherwise change the required type.
+
+### Unused method handle result
+
+Before:
+
+```text
+int ignored = (int)handle.invokeExact(argument);
+```
+
+Prefer on Java 22 or later:
+
+```java
+var _ = (int)handle.invokeExact(argument);
+```
+
+Keep the named local on older targets.
+Do not replace the assignment with `handle.invokeExact(argument);`.
+That call expects a `void` return type instead of `int`.
+
+### Type test and cast
+
+Before:
+
+```text
+if (value instanceof String) {
+  String text = (String)value;
+  return text.length();
+}
+```
+
+Prefer:
+
+```java
+if (value instanceof String text) {
+  return text.length();
+}
+```
+
+### Value-returning switch
+
+Before:
+
+```text
+switch (exitCode) {
+  case 0: return Result.SUCCESS;
+  default: return Result.FAILURE;
+}
+```
+
+Prefer:
+
+```java
+return switch (exitCode) {
+  case 0 -> Result.SUCCESS;
+  default -> Result.FAILURE;
+};
+```
+
+### Value carrier
+
+For a new internal value type, avoid this class boilerplate:
+
+```text
+final class ExitCode {
+  private final int value;
+
+  ExitCode(int value) {
+    this.value = value;
+  }
+
+  int value() {
+    return value;
+  }
+}
+```
+
+Prefer:
+
+```java
+record ExitCode(int value) { }
+```
+
+The record also defines value equality, hashing, and a string representation.
+This is not an automatic replacement for an existing class with identity semantics.
+
+### Multiline text
+
+Before:
+
+```text
+String payload = "{\n  \"enabled\": true\n}\n";
+```
+
+Prefer:
+
+```java
+var payload = """
+  {
+    "enabled": true
+  }
+  """;
+```
+
+### Collection creation
+
+Before:
+
+```text
+List<String> names = Collections.unmodifiableList(Arrays.asList("alpha", "beta"));
+```
+
+Prefer on Java 10 or later:
+
+```java
+var names = List.of("alpha", "beta");
+```
+
+On Java 9, keep the explicit variable type and use `List.of`.
+
+## Source and adaptations
+
+Adapted from Ken Kousen's [modernize-java skill][upstream] at revision `aec3f82a47ac27928732de61ea8e58f4e192eeb5`.
+The original MIT notice is in [modern-java.LICENSE.txt](modern-java.LICENSE.txt).
+
+This adaptation adds feature versions, examples, and IntelliJ constraints.
+It makes `var` the default and replaces blanket advice about virtual threads.
+It covers writing and reviewing Java, not only refactoring. Repository instructions define how to build and test the affected modules.
+Update the pinned source only as part of a reviewed change.
+
+[upstream]: https://github.com/kousen/claude-code-training/blob/aec3f82a47ac27928732de61ea8e58f4e192eeb5/skills/modernize-java/SKILL.md
+[language]: https://docs.oracle.com/en/java/javase/25/language/java-language-changes-summary.html
+[collections]: https://docs.oracle.com/en/java/javase/25/core/creating-immutable-lists-sets-and-maps.html
+[list-api]: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/List.html