From 00093be8afc240c75345e33fe20457641ad5769e Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 7 May 2026 08:48:44 +0200 Subject: [PATCH 1/5] Bump Magick.NET-Q8-AnyCPU from 14.10.4 to 14.12.0 (#35315) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Updated [Magick.NET-Q8-AnyCPU](https://github.com/dlemstra/Magick.NET) from 14.10.4 to 14.12.0.
Release notes _Sourced from [Magick.NET-Q8-AnyCPU's releases](https://github.com/dlemstra/Magick.NET/releases)._ ## 14.12.0 ### What's Changed - Added `FixByteOrder` to the `DcmReadDefines` (#​1976) - Added `IconWriteDefines`. ### Related changes in ImageMagick since the last release of Magick.NET: - Correct bug in `Composite` when using `CopyAlpha` (#​1985) - Fixed incorrect orientation of JPEG compressed TIFF images (#​1991) - Heap-Buffer-Overflow write of single zero byte when parsing xml (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-cr67-pvmx-2pp2) - Stack Overflow in DestroyXMLTree (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-fwvm-ggf6-2p4x) - Out-of-Bounds read in sample operation (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-pcvx-ph33-r5vv) - Stack Overflow via Recursive FX Expression Parsing (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-f4qm-vj5j-9xpw) - Heap Buffer Overflow in ImageMagick MVG decoder (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-x9h5-r9v2-vcww) - Heap overflow caused by integer overflow/wraparound in viff encoder on 32-bit builds (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-v67w-737x-v2c9) - Stack-buffer-overflow in MNG encoder with oversized pallete (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-98cp-rj9f-6v5g) - Integer overflow in despeckle operation causes heap buffer overflow on 32-bit builds (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-26qp-ffjh-2x4v) - Off-by-One in MSL decoder could result in crash (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-5xg3-585r-9jh5) - Heap buffer overflow when encoding JXL image with a 16-bit float (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-jvgr-9ph5-m8v4) - Heap-use-after-free via XMP profile could result in a crash when printing the values (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-r83h-crwp-3vm7) - Heap buffer overflow (WRITE) in the YAML and JSON encoders (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-5592-p365-24xh) - Heap out-of-bounds write in JP2 encoder (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-pwg5-6jfc-crvh) ### Library updates: - ImageMagick 7.1.2-19 (2026-04-12) - aom 3.13.3 (2026-04-02) - openexr 3.4.9 (2026-04-03) - freetype 2.14.3 (2026-03-22) - gdk-pixbuf 2.44.6 (2026-03-31) - harfbuzz 14.0.0 (2026-04-01) - liblzma 5.8.3 (2026-04-31) - libpng 1.6.56 (2026-03-25) **Full Changelog**: https://github.com/dlemstra/Magick.NET/compare/14.11.1...14.12.0 ## 14.11.1 ### Related changes in ImageMagick since the last release of Magick.NET: - Stack-buffer-overflow WRITE in InterpretImageFilename due to overflow (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-8793-7xv6-82cf) ### Library updates: - ImageMagick 7.1.2-18 (2026-03-23) - aom 3.13.2 (2026-03-19) - openexr 3.4.7 (2026-03-15) - harfbuzz 13.2.1 (2026-03-19) **Full Changelog**: https://github.com/dlemstra/Magick.NET/compare/14.11.0...14.11.1 ## 14.11.0 ### What's Changed - Added `DcmReadDefines`. ### Related changes in ImageMagick since the last release of Magick.NET: - Access mode change for files created from 0666 to 0600 (https://github.com/ImageMagick/ImageMagick/issues/8609) - Heap-buffer-overflow in NewXMLTree could result in crash (https://github.com/ImageMagick/ImageMagick/security/advisories/GHSA-gc62-2v5p-qpmp) ### Library updates: - ImageMagick 7.1.2-17 (2026-03-16) - openexr 3.4.6 (2026-03-01) - freetype 2.14.2 (2026-03-01) - harfbuzz 13.0.1 (2026-03-07) - libxml2 2.15.2 (2026-03-03) **Full Changelog**: https://github.com/dlemstra/Magick.NET/compare/14.10.4...14.11.0 Commits viewable in [compare view](https://github.com/dlemstra/Magick.NET/compare/14.10.4...14.12.0).
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Magick.NET-Q8-AnyCPU&package-manager=nuget&previous-version=14.10.4&new-version=14.12.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dotnet/maui/network/alerts).
Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- .../VisualTestUtils.MagickNet/VisualTestUtils.MagickNet.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/TestUtils/src/VisualTestUtils.MagickNet/VisualTestUtils.MagickNet.csproj b/src/TestUtils/src/VisualTestUtils.MagickNet/VisualTestUtils.MagickNet.csproj index 7f1abf940168..220a50e160b9 100644 --- a/src/TestUtils/src/VisualTestUtils.MagickNet/VisualTestUtils.MagickNet.csproj +++ b/src/TestUtils/src/VisualTestUtils.MagickNet/VisualTestUtils.MagickNet.csproj @@ -6,7 +6,7 @@ - + From af01b74822fb91b01d8bdd72490aa4b616c17d5f Mon Sep 17 00:00:00 2001 From: Gerald Versluis Date: Thu, 7 May 2026 11:50:16 +0200 Subject: [PATCH 2/5] Bump OpenTelemetry packages in Aspire ServiceDefaults template (#35333) Bump OpenTelemetry packages to latest stable versions in the maui-aspire-servicedefaults template: - OpenTelemetry.Exporter.OpenTelemetryProtocol: 1.9.0 to 1.15.3 - OpenTelemetry.Extensions.Hosting: 1.9.0 to 1.15.3 - OpenTelemetry.Instrumentation.Http: 1.9.0 to 1.15.1 - OpenTelemetry.Instrumentation.Runtime: 1.9.0 to 1.15.1 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../MauiAspire.1.ServiceDefaults.csproj | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Templates/src/templates/maui-aspire-servicedefaults/MauiAspire.1.ServiceDefaults.csproj b/src/Templates/src/templates/maui-aspire-servicedefaults/MauiAspire.1.ServiceDefaults.csproj index d011350b2f8d..051e316564d0 100644 --- a/src/Templates/src/templates/maui-aspire-servicedefaults/MauiAspire.1.ServiceDefaults.csproj +++ b/src/Templates/src/templates/maui-aspire-servicedefaults/MauiAspire.1.ServiceDefaults.csproj @@ -11,9 +11,9 @@ - - - - + + + + From d886e09fcf6fb5915330a26f972701680ff275d5 Mon Sep 17 00:00:00 2001 From: "dotnet-maestro[bot]" <42748379+dotnet-maestro[bot]@users.noreply.github.com> Date: Thu, 7 May 2026 11:49:11 -0500 Subject: [PATCH 3/5] [main] Update dependencies from dotnet/xharness (#35292) This pull request updates the following dependencies [marker]: <> (Begin:a71c12d9-5aa4-4b46-e2d6-08da0cf8cd95) ## From https://github.com/dotnet/xharness - **Subscription**: [a71c12d9-5aa4-4b46-e2d6-08da0cf8cd95](https://maestro.dot.net/subscriptions?search=a71c12d9-5aa4-4b46-e2d6-08da0cf8cd95) - **Build**: [20260430.4](https://dev.azure.com/dnceng/internal/_build/results?buildId=2964906) ([312724](https://maestro.dot.net/channel/2/github:dotnet:xharness/build/312724)) - **Date Produced**: May 1, 2026 7:05:11 AM UTC - **Commit**: [92962e5c46ac08a66ded4c5696209cc60f1a232f](https://github.com/dotnet/xharness/commit/92962e5c46ac08a66ded4c5696209cc60f1a232f) - **Branch**: [main](https://github.com/dotnet/xharness/tree/main) [DependencyUpdate]: <> (Begin) - **Dependency Updates**: - From [11.0.0-prerelease.26229.1 to 11.0.0-prerelease.26230.4][1] - Microsoft.DotNet.XHarness.CLI - Microsoft.DotNet.XHarness.TestRunners.Common - Microsoft.DotNet.XHarness.TestRunners.Xunit [1]: https://github.com/dotnet/xharness/compare/9d5a7e9623...92962e5c46 [DependencyUpdate]: <> (End) [marker]: <> (End:a71c12d9-5aa4-4b46-e2d6-08da0cf8cd95) Co-authored-by: dotnet-maestro[bot] --- .config/dotnet-tools.json | 2 +- eng/Version.Details.xml | 12 ++++++------ eng/Versions.props | 6 +++--- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 10311f4926d5..a06771ae3239 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -24,7 +24,7 @@ "rollForward": false }, "microsoft.dotnet.xharness.cli": { - "version": "11.0.0-prerelease.26229.1", + "version": "11.0.0-prerelease.26230.4", "commands": [ "xharness" ], diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml index e7376bb48184..acff08c44cb7 100644 --- a/eng/Version.Details.xml +++ b/eng/Version.Details.xml @@ -166,17 +166,17 @@ https://github.com/dotnet/dotnet 7b29526f2107416f68578bcb9deaca74fcfcf7f0 - + https://github.com/dotnet/xharness - 9d5a7e96236317f6312b25590e93ce6c363b62c3 + 92962e5c46ac08a66ded4c5696209cc60f1a232f - + https://github.com/dotnet/xharness - 9d5a7e96236317f6312b25590e93ce6c363b62c3 + 92962e5c46ac08a66ded4c5696209cc60f1a232f - + https://github.com/dotnet/xharness - 9d5a7e96236317f6312b25590e93ce6c363b62c3 + 92962e5c46ac08a66ded4c5696209cc60f1a232f diff --git a/eng/Versions.props b/eng/Versions.props index 4f97597832f3..db665fa0fa24 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -137,9 +137,9 @@ <_HarfBuzzSharpVersion>8.3.0.1 <_SkiaSharpNativeAssetsVersion>0.0.0-commit.e57e2a11dac4ccc72bea52939dede49816842005.1728 7.0.120 - 11.0.0-prerelease.26229.1 - 11.0.0-prerelease.26229.1 - 11.0.0-prerelease.26229.1 + 11.0.0-prerelease.26230.4 + 11.0.0-prerelease.26230.4 + 11.0.0-prerelease.26230.4 0.9.2 2.0.0.4 1.3.0 From b71adea6e63829f4fc264302f1cad08aa542c794 Mon Sep 17 00:00:00 2001 From: Jakub Florkowski <42434498+kubaflo@users.noreply.github.com> Date: Thu, 7 May 2026 20:33:57 +0200 Subject: [PATCH 4/5] History-trained agentic files + expert reviewer (#35198) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit > [!NOTE] > Are you waiting for the changes in this PR to be merged? > It would be very helpful if you could [test the resulting artifacts](https://github.com/dotnet/maui/wiki/Testing-PR-Builds) from this PR and let us know in a comment if this change resolves your issue. Thank you! ## Description Replaces `review-rules.md` (flat 345-line checklist) with a dimensional expert review agent. Single source of truth for all review rules, organized into 30 dimensions for per-dimension sub-agent evaluation. Adds inline file:line PR comments alongside the existing wall-of-text summary. Extracted from 28k review comments across 5 maintainers via [extraction-pipeline](https://github.com/dotnet/fsharp/blob/main/.github/agents/extraction-pipeline.md). No functional code changes. Recreated from #35062 on a dotnet/maui branch (originally opened from a fork). ## What changed **Before:** `review-rules.md` had 345 lines of flat rules. `code-review` skill loaded them all into one context. Output was a single wall-of-text PR comment. **After:** Rules absorbed into `maui-expert-reviewer.md` as 30 dimensions with 200+ CHECK items. Each dimension runs as an independent sub-agent with focused context. Output is inline file:line PR comments via `inline-findings.json`. ## CI Flow ``` Review-PR.ps1 prompt: 1. code-review → maui-expert-reviewer agent → inline-findings.json 2. pr-review → Pre-Flight → Try-Fix → Report (sees findings, no duplication) Posting: post-inline-review.ps1 → .json → GitHub file:line comments (NEW) post-ai-summary-comment.ps1 → {phase}/content.md → wall-of-text (existing) CI: COMMENTS_VIA_FILE=true → agent writes .json, script posts Local: agent writes .json, code-review posts directly via gh api ``` ## Files | Action | File | What | |--------|------|------| | **Add** | `agents/maui-expert-reviewer.md` | 30 dimensions, 200+ CHECKs, routing table | | **Add** | `instructions/collectionview-{android,ios,windows}` | Platform-isolated CV rules | | **Add** | `instructions/{handler-patterns,layout-system,performance-hotpaths,public-api,threading-async}` | Domain-specific ambient guidance | | **Add** | `scripts/post-inline-review.ps1` | Posts .json as GitHub PR review | | **Del** | `skills/code-review/references/review-rules.md` | Absorbed into agent | | **Mod** | `skills/code-review/SKILL.md` | Delegates to agent | | **Mod** | `scripts/Review-PR.ps1` | Prompt + inline posting wiring | | **Mod** | `eng/pipelines/ci-copilot.yml` | `COMMENTS_VIA_FILE` env var | --------- Co-authored-by: kubaflo Co-authored-by: T-Gro <46543583+T-Gro@users.noreply.github.com> Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: Tomas Grosup --- .github/agents/maui-expert-reviewer.md | 606 ++++++++++++++++++ .../collectionview-android.instructions.md | 32 + .../collectionview-ios.instructions.md | 34 + .../collectionview-windows.instructions.md | 26 + .../handler-patterns.instructions.md | 36 ++ .../layout-system.instructions.md | 30 + .../performance-hotpaths.instructions.md | 34 + .../instructions/public-api.instructions.md | 36 ++ .../threading-async.instructions.md | 34 + .github/scripts/Review-PR.ps1 | 294 ++++++++- .github/scripts/post-inline-review.ps1 | 264 ++++++++ .github/scripts/shared/Detect-TestsInDiff.ps1 | 58 +- .github/skills/code-review/SKILL.md | 80 ++- .../code-review/references/review-rules.md | 345 ---------- .github/skills/code-review/tests/eval.yaml | 4 +- .github/skills/pr-review/SKILL.md | 12 +- .github/skills/try-fix/SKILL.md | 213 +++++- .../try-fix/references/example-invocation.md | 2 +- .../scripts/verify-tests-fail.ps1 | 141 +++- eng/pipelines/ci-copilot.yml | 1 + 20 files changed, 1833 insertions(+), 449 deletions(-) create mode 100644 .github/agents/maui-expert-reviewer.md create mode 100644 .github/instructions/collectionview-android.instructions.md create mode 100644 .github/instructions/collectionview-ios.instructions.md create mode 100644 .github/instructions/collectionview-windows.instructions.md create mode 100644 .github/instructions/handler-patterns.instructions.md create mode 100644 .github/instructions/layout-system.instructions.md create mode 100644 .github/instructions/performance-hotpaths.instructions.md create mode 100644 .github/instructions/public-api.instructions.md create mode 100644 .github/instructions/threading-async.instructions.md create mode 100644 .github/scripts/post-inline-review.ps1 delete mode 100644 .github/skills/code-review/references/review-rules.md diff --git a/.github/agents/maui-expert-reviewer.md b/.github/agents/maui-expert-reviewer.md new file mode 100644 index 000000000000..56efe5638df5 --- /dev/null +++ b/.github/agents/maui-expert-reviewer.md @@ -0,0 +1,606 @@ +--- +name: maui-expert-reviewer +description: "Reviews .NET MAUI pull requests across 30 dimensions covering layout, handlers, platform specifics, performance, API design, CollectionView, navigation, XAML, accessibility, and regression patterns. Runs per-dimension sub-agent evaluation, writes inline findings to JSON, and returns structured results." +--- + +# MAUI Expert Reviewer + +You review .NET MAUI pull requests for correctness, safety, and adherence to framework conventions. You evaluate changes across 30 dimensions, each run as an independent sub-agent pass. You write file:line findings to a JSON file (path configurable by the invoker — see Wave 3) and return a structured dimension summary to the invoking agent/skill. + +**Scope**: Code review only. Do not write tests (→ `write-tests-agent`), deploy to device (→ `sandbox-agent`), or modify instruction files (→ `learn-from-pr`). + +--- + +## Overarching Principles + +1. **Every bug fix needs a regression test** that reproduces the original issue scenario, not just a generic unit test. +2. **Verify logic against the original reproduction** before and after the fix — a fix that passes new tests but fails the original repro is wrong. +3. **Code must live at the correct abstraction layer** — Core vs Controls, handler vs extension method, shared vs platform-specific. +4. **Hot paths must avoid allocations** — no LINQ, closures, or temporary collections in measure/arrange, scroll, or binding propagation. +5. **Property updates go through the mapper system** (`UpdateValue`) — direct calls bypass `AppendToMapping`/`PrependToMapping` customizations. +6. **Null-check VirtualView and MauiContext** before use in every handler callback — both can be null during lifecycle transitions. +7. **Platform-specific changes must not break other platforms** — scope changes or add cross-platform regression tests. +8. **Check git history before modifying existing code** — understand WHY it was added to avoid re-introducing fixed bugs. + +--- + +## Review Dimensions + +### 1. Layout Measure-Arrange Correctness `[critical]` + +Constraint propagation through parent-child hierarchy, no infinite loops, content size tracking consistency. + +- CHECK: Measure and arrange passes use consistent constraints — a child measured at width=200 must not be arranged at width=300 +- CHECK: Layout invalidation triggers re-measure when parent container size changes +- CHECK: ScrollView content is always re-measured on layout trigger (no aggressive caching) +- CHECK: Padding, margin, and border thickness are subtracted before passing constraints to children +- CHECK: No infinite measure/arrange oscillation from circular size dependencies +- CHECK: ArrangeOverride respects the size returned from MeasureOverride +- CHECK: Collection changes propagate via `Handler.UpdateValue(PropertyName)` at the Controls level, not via `INotifyCollectionChanged` from the platform view — INCC creates tight coupling +- CHECK: Guard against infinite `ContentSize` oscillation on iOS — `MauiScrollView` can loop when content triggers layout→resize→layout cycles; use pixel-level comparison (e.g., `EqualsAtPixelLevel` threshold ~0.0000001pt) to break sub-pixel noise from animations +- CHECK: Don't apply padding in aspect ratio calculations — compute ratio first, then add padding +- CHECK: Test visibility propagation through nested containers with full matrix: 2-level and 3-level nesting, set/unset sequences + +#### Platform notes +- **iOS**: Measure and layout passes must stay in sync; out-of-sync causes redraw failures. Compare sizes at pixel resolution to absorb device-pixel rounding. +- **Android**: RecyclerView item measurement must account for pixel rounding +- **Windows**: WinUI uses NaN conventions for unconstrained dimensions + +### 2. Performance-Critical Path Optimization `[major]` + +Avoiding expensive operations on hot paths: measure/arrange, scrolling, binding propagation, property change notifications. + +- CHECK: No LINQ (`.Where`, `.Select`, `.FirstOrDefault`) on measure/arrange/scroll paths — use indexed `for` loops +- CHECK: No unnecessary allocations (closures, temporary collections, string concatenation) in frequently-called methods +- CHECK: Bindable property change handlers skip layout invalidation when value has not actually changed +- CHECK: Collection iteration uses `Count`/indexer rather than `IEnumerable` allocation when source supports it +- CHECK: Expensive computations called multiple times per layout pass are cached with proper invalidation +- CHECK: Cache JNI property access in locals — Android properties like `Context`, `Resources`, `ContentDescription` cross the Java/C# bridge on every access +- CHECK: Avoid closures that capture UIKit objects — they create GC-tracked references that increase memory pressure; prefer explicit parameter passing or static methods +- CHECK: `ValueTuple.GetHashCode()` may allocate for large tuples — implement `GetHashCode()` explicitly for hash-critical types like `SetterSpecificity` +- CHECK: Public APIs return `IReadOnlyList` or `IReadOnlyCollection` instead of mutable `List` +- CHECK: Use `StringBuilder` or `List` for source generator string building — repeated `+=` is O(n²) +- CHECK: Allocate early, check cheap conditions first — test boolean flags and null checks before allocating strings or doing I/O in mapper callbacks +- CHECK: Don't remove caches without benchmarks — replacements must prove equivalent or better performance via `dotnet-trace`/`speedscope.app` +- CHECK: Flatten nested LINQ into single-level iteration when possible, but benchmark to verify improvement + +### 3. Handler Mapper and Property Patterns `[major]` + +Correct usage of mapper/command-mapper, lifecycle symmetry, and chained mapper handling. + +- CHECK: Property updates go through `Handler.UpdateValue(nameof(Property))`, not direct mapper calls +- CHECK: Mapper registrations use `AppendToMapping`/`PrependToMapping` for extensibility +- CHECK: Handler properties are initialized in correct dependency order +- CHECK: CommandMapper entries return void and use `(handler, view, args)` signature — Commands are for requests (`ScrollTo`, `Remove`), Mapper properties associate with `BindableProperty` values +- CHECK: Platform-specific mapper overrides call base mapper when extending +- CHECK: **ConnectHandler/DisconnectHandler symmetry** — every listener, event handler, or callback registered in `ConnectHandler` must be unregistered in `DisconnectHandler` +- CHECK: Don't null handler references eagerly in `DisconnectHandler` — the view might be removed and re-added (e.g., Shell tab switching); clear subscriptions while keeping weak references alive +- CHECK: On Android, assign per-view state in `AttachedToWindow`/`DetachedFromWindow` rather than constructor to avoid leaks when views are recycled +- CHECK: Use `ModifyMapping` for Controls-layer overrides that override Core behavior, so user-registered mappings aren't silently replaced +- CHECK: Mapper methods must be idempotent — they can be called at any time, not just initial setup; must fully initialize state from scratch +- CHECK: `ConnectHandler` calls `base.ConnectHandler()` before custom setup; `DisconnectHandler` cleans up before calling `base.DisconnectHandler()` — reversed ordering can access disposed resources +- CHECK: Centralize listener instances via static registry for per-CoordinatorLayout or per-DrawerLayout listeners to reduce allocations + +### 4. Architectural Layer Placement `[moderate]` + +Code lives at the correct abstraction: Core vs Controls, handler vs extension method, shared vs platform-specific. + +- CHECK: Platform-agnostic logic lives in shared code, not in platform handler implementations +- CHECK: Extension methods on platform types do not contain business logic belonging in the handler +- CHECK: Cross-cutting behavior uses IView/IElement interfaces, not per-control duplication +- CHECK: Compatibility shim logic stays in the Compatibility layer, not leaked into Core handlers +- CHECK: Navigation logic belongs in Shell/NavigationPage handlers, not in individual page handlers + +### 5. Logic and Correctness Verification `[critical]` + +Catching inverted conditions, off-by-one errors, wrong property usage, or semantic errors. + +- CHECK: Boolean conditions are not inverted (checking `IsVisible` when meaning `!IsVisible`) +- CHECK: Correct property is used when similar ones exist (`RawX` vs `X`, `Bounds` vs `Frame`) +- CHECK: Edge cases handled: empty collections, zero dimensions, null parents, single-item scenarios +- CHECK: Fix is verified against the original issue reproduction, not just a new unit test +- CHECK: Arithmetic handles overflow, division by zero, and negative values +- CHECK: Explicit parentheses in index/position/offset calculations — silent operator-precedence bugs in scroll offset, spacing, or size math are hard to spot + +### 6. Regression Prevention and Test Coverage `[critical]` + +Every bug fix needs a regression test. Modified code must be checked against git history. + +- CHECK: Bug fix includes a regression test reproducing the original issue +- CHECK: Reverted or modified code is checked via git blame for why it was added +- CHECK: Test covers the specific scenario from the issue report, not a generic case +- CHECK: Shared code changes are tested on all affected platforms +- CHECK: Previously-fixed issue numbers are cross-referenced when modifying the same code area +- CHECK: UI tests run on all applicable platforms unless there is a specific technical limitation +- CHECK: Snapshot baselines updated across all platforms when changing background color, font, or layout +- CHECK: Screenshot size matches capture method — a size mismatch means the capture changed, not the rendering +- CHECK: Use `VerifyScreenshot(retryTimeout:)` instead of `Task.Delay` — built-in retry handles animations +- CHECK: Test labels are visible even when content is clipped — position a sentinel element inside the clip boundary to prove content was drawn +- CHECK: Android memory tests use `GetMemoryInfo()` with threshold assertions +- CHECK: Test types match project infrastructure — source-gen tests in `SourceGen.UnitTests.csproj`, not `Xaml.UnitTests.csproj`; tests that don't need `[Values] XamlInflator` shouldn't use it + +#### Frequently Regressed Components + +Use this as a triage guide — PRs touching these warrant extra scrutiny on adjacent scenarios: + +| Component | Key Risk Areas | +|-----------|----------------| +| CollectionView | Layout, scroll position, spacing, cell alignment, Header/Footer | +| Image/Graphics | Aspect ratio, CornerRadius, Background, DrawString | +| Theme/Style | AppThemeBinding, implicit styles, ApplyToDerivedTypes | +| CarouselView | ScrollTo, CurrentItem, ItemSpacing, loop mode | +| Gesture/Tap | TapGestureRecognizer, SwipeView, outside-tap dismiss | +| Button/Entry | Dynamic resize, focus/selection, AppThemeBinding colors | +| Toolbar | Icon color, back button, BarTextColor across modes | +| Shell/TabBar | TabBarIsVisible, Shell crashes, section rendering | + +#### Regression Escalation Patterns + +Lessons from reverted PRs and candidate-branch failures. When a PR touches these areas, apply extra scrutiny. + +- CHECK: **Test the fix scenario AND adjacent scenarios** — most reverts happen because the fix works for the reported issue but breaks a neighboring case; require authors to enumerate adjacent behaviors checked +- CHECK: **Never remove `InternalsVisibleTo` without auditing NuGet consumers** — IVT removal silently breaks community packages depending on internal APIs +- CHECK: **Entry/Editor focus and selection state is fragile** — `CursorPosition`, `SelectionLength`, keyboard show/hide, and focus order interact tightly; verify focus behavior especially when keyboard is dismissed and re-shown +- CHECK: **iOS measurement timing lags behind property changes** — `UIButton.TitleLabel.Bounds` and `UIView` frame values are not updated synchronously; measure the title manually instead of reading `.Bounds` immediately after setting a property +- CHECK: **Template changes need all-template validation** — a fix for `maui` can break `maui-blazor` or `maui-multiproject`; validate against all template IDs +- CHECK: **Candidate-branch PRs must not mix concerns** — don't bundle unrelated flakiness fixes with regression fixes; mixed PRs make bisection impossible +- CHECK: **Major dependency upgrades need broad platform validation** — WindowsAppSDK, platform SDK bumps, etc. must be green on all platforms before merge +- CHECK: **ContentPresenter BindingContext propagation breaks explicit TemplateBindings** — propagating `BindingContext` through `ContentPresenter` overwrites `{TemplateBinding}` values; verify TemplateBinding expressions still resolve after the change + +### 7. Public API Surface Design `[major]` + +Additions, removals, or changes to public APIs for intentionality and forward-compatibility. + +- CHECK: New public APIs have clear use cases — no speculative additions +- CHECK: Deprecated APIs are marked `[Obsolete]` with migration guidance before removal; message ends with a period (iOS Cecil tests enforce this) +- CHECK: API naming follows .NET design guidelines and existing MAUI patterns +- CHECK: Breaking changes are documented with explicit design justification +- CHECK: `PublicAPI.Unshipped.txt` entries match the actual API shape +- CHECK: Adding members to a public interface is a breaking change — use default interface methods, create a versioned interface (`IFoo2`), or add an extension method +- CHECK: Never modify `PublicAPI.Shipped.txt` — to remove a shipped API, copy the line to `Unshipped.txt` prefixed with `*REMOVED*` +- CHECK: Don't expose setters that do nothing — dead setters accumulate API surface that can't be removed later +- CHECK: Public `MauiAppBuilder` extension methods cannot be removed once added — evaluate carefully what belongs on the builder +- CHECK: When replacing types, consider keeping a compatibility class that inherits from the new type to ease Xamarin.Forms migration + +### 8. Async and Threading Safety `[major]` + +Correct async/await, UI thread dispatching, cancellation tokens, and race condition prevention. + +- CHECK: Fire-and-forget async uses `.FireAndForget()` with exception handling, not bare `async void` +- CHECK: Platform view modifications are dispatched to the UI thread from background contexts +- CHECK: CancellationToken is threaded through long-running operations +- CHECK: Async handler operations verify the handler is still connected before applying results +- CHECK: Concurrent access to shared state is protected (lock, Interlocked, or immutable patterns) +- CHECK: Use `Interlocked.Increment` for counters accessed from the UI thread — even "most likely single-threaded" counters need safety for debounce correctness +- CHECK: Don't reset debounce counters to zero — roll over at a high threshold (e.g., 100) to prevent missed update requests from race conditions +- CHECK: Check if already on the main thread before dispatching — unnecessary dispatch adds latency and can reorder operations +- CHECK: `Task.Delay` in tests needs justification — prefer deterministic helpers like `WaitForMainThread()` over arbitrary millisecond waits +- CHECK: Guard `DispatcherQueue` for null on Windows before posting — it can be null if the Window is disposed + +#### Platform dispatch +- **Android**: `platformView.Post()` for UI thread; `Looper.MainLooper` for thread check +- **iOS**: `MainThread.BeginInvokeOnMainThread` or `DispatchQueue.MainQueue` +- **Windows**: `DispatcherQueue.TryEnqueue`; be aware of COM apartment model + +### 9. Null Safety and Defensive Coding `[moderate]` + +Null checks, early returns, and nullable annotations to prevent NREs where object availability timing varies by platform. + +- CHECK: VirtualView is null-checked in handler callbacks — it can be null during disconnect +- CHECK: MauiContext is validated; throw `InvalidOperationException` with descriptive message if null +- CHECK: Platform callbacks guard against null native views (may be collected or disconnected) +- CHECK: Nullable annotations (`?`) match actual nullability — no `!` suppression without justification +- CHECK: Early return pattern used when null check makes remaining code unreachable +- CHECK: Check if stream is seekable (`CanSeek`) before copying — use the original stream directly if seekable +- CHECK: Fall back to `Application.Current.FindMauiContext()` when `Window.MauiContext` is null +- CHECK: Initialize WebView cookies in `CoreWebView2Initialized` — preloading before `CoreWebView2` init hits null references +- CHECK: Try-catch for fire-and-forget platform calls that can fail non-critically — unhandled exceptions crash the app +- CHECK: Guard against empty collections in chained calls — `collection?.FirstOrDefault().ToPlatform()` throws if collection is empty (not null); check `.Any()` first + +### 10. Cross-Platform Behavioral Consistency `[moderate]` + +Same feature produces equivalent user-visible behavior across all target platforms. + +- CHECK: New control behavior is implemented on all platforms, not just the one that reported the bug +- CHECK: Platform-specific workarounds are documented with TODO for future alignment +- CHECK: Default property values produce the same visual result across platforms +- CHECK: Event firing order and frequency are consistent across platforms + +### 11. Memory Leak Prevention `[major]` + +Proper event unsubscription, weak references, and GC eligibility after visual tree removal. + +- CHECK: Event handlers are unsubscribed in DisconnectHandler using `-=` or nulling the delegate +- CHECK: Views and ViewModels become GC-eligible after removal from visual tree +- CHECK: Weak references are used for long-lived observers of short-lived objects +- CHECK: Memory leak tests verify collection with WeakReference pattern +- CHECK: Store handler references as `WeakReference` — a strong handler↔platform view cycle prevents collection, especially on iOS +- CHECK: Prefer delegates/`Func<>` over handler references — layout code uses `Func<>` callbacks to avoid coupling to handler instances +- CHECK: Prefer static callbacks on iOS — move gesture recognizer callbacks and event handlers into static methods, passing state through sender/tag +- CHECK: Unsubscribe Android listeners (`view.SetOnXxxListener(null)`) in DisconnectHandler — removes Java's reference that blocks GC of the handler +- CHECK: Closures capturing UIKit views (`UIView`, `UIScrollView`, `NSObject` subclasses) create hidden strong references — extract to local, use weak capture, or mark lambda `static` +- CHECK: Static `NSString` constants should be `static readonly` fields, not allocated on every use +- CHECK: CollectionView data stored via attached properties on `BindableObject` persists for the CV's lifetime — for per-item data, store on the handler instance instead +- CHECK: When adding new event subscriptions or handler references, consider adding a leak-detection device test + +#### Platform notes +- **Android**: Unsubscribe listeners in DisconnectHandler. Do NOT call Dispose on platform objects — the GC bridge handles collection. +- **iOS**: Prefer static callbacks to avoid retain cycles; remove NSNotificationCenter observers. Reference-counting GC is especially sensitive to cycles. + +### 12. Backward Compatibility and Migration `[major]` + +Breaking changes, Xamarin.Forms migration paths, and third-party renderer impact. + +- CHECK: Behavioral changes from Xamarin.Forms have explicit design justification +- CHECK: Removed/renamed APIs go through `[Obsolete]` cycle before removal +- CHECK: Default property value changes are evaluated for impact on existing apps +- CHECK: Compatibility renderers maintain behavioral parity with handler equivalents + +### 13. Platform-Specific Code Scoping `[moderate]` + +Correct `#if` guards, API-level checks, platform file extensions, and namespace conventions. + +- CHECK: `#if ANDROID`/`IOS`/`WINDOWS` guards scope code to correct compilation targets +- CHECK: Android API-level checks use `Build.VERSION.SdkInt`, not version string parsing +- CHECK: Files use correct extension (`.android.cs`, `.ios.cs`, `.windows.cs`) +- CHECK: `System.OperatingSystem` APIs used for linker-friendly runtime platform detection +- CHECK: Use type aliases for namespace collisions — `using AView = Android.Views.View;`, `using NativeScrollView = Microsoft.UI.Xaml.Controls.ScrollViewer;`, etc. +- CHECK: Platform views live in `Microsoft.Maui.Platform` namespace, under `Platform//` +- CHECK: Don't change handler generic type parameters — e.g., `ViewHandler` → `ViewHandler` is a binary breaking API change +- CHECK: When fixing behavior on one platform, verify consistency on others — reviewers will ask "What does Windows/Android do here?" +- CHECK: Reuse platform APIs via extension methods — don't duplicate logic that already exists + +#### Platform notes +- **Android**: API-level checks required for features across SDK 23–36 +- **iOS**: `.ios.cs` compiles for BOTH iOS and MacCatalyst; use `.maccatalyst.cs` for MacCatalyst-only +- **Windows**: WinUI version checks may be needed for specific Windows App SDK features + +### 14. Native Platform Defaults Preservation `[moderate]` + +Storing and restoring native defaults before applying cross-platform overrides. + +- CHECK: Native defaults are captured BEFORE any cross-platform property is applied in ConnectHandler +- CHECK: Clearing a property (setting to null/default) restores the captured native default, not a hardcoded value +- CHECK: Platform styles (WinUI XAML, iOS storyboards) are respected as defaults +- CHECK: Font resolution in compatibility renderers matches handler behavior for DefaultFont lookup + +#### Platform notes +- **Windows**: WinUI XAML styles must be preserved; clearing color restores style-applied color, not transparent + +### 15. Safe Area and Window Insets `[critical]` + +Safe area adjustments, keyboard insets, and ancestor hierarchy walks. See `safe-area-ios.instructions.md` for detailed architecture. + +- CHECK: Ancestor walk checks handle the SAME edges — parent handling Top does not block child handling Bottom +- CHECK: Safe area comparison uses pixel-level tolerance to absorb sub-pixel animation noise +- CHECK: Never gate per-view safe area callbacks on window-level insets (they diverge on MacCatalyst with custom TitleBar) +- CHECK: Safe area caches are invalidated on inset changes and window transitions +- CHECK: Only `ISafeAreaView`/`ISafeAreaView2` views receive safe area adjustments — non-safe-area views must return empty padding +- CHECK: Raw vs adjusted inset comparison — `_safeArea` is filtered by `GetSafeAreaForEdge`; raw `UIView.SafeAreaInsets` includes all edges; never compare across types +- CHECK: Use constants for magic strings — property names like `"SafeAreaInsets"` must be constants, not bare strings +- CHECK: New safe area types belong in `src/Core` so `ISafeAreaView2` can reference them — don't add core interface deps to `Controls.csproj` +- CHECK: Before creating versioned interfaces (`ISafeAreaView2`), check if the existing interface can be extended with default interface methods + +#### Platform notes +- **iOS/MacCatalyst**: See `safe-area-ios.instructions.md` for `IsParentHandlingSafeArea`, `EqualsAtPixelLevel`, and the Window Guard anti-pattern. macCatalyst defaults `UseSafeArea` to `true` (unlike iOS where it's `false`). +- **Android**: `WindowInsetsCompat` for keyboard and system bar; `fitsSystemWindows` behavior differs by API level + +### 16. Complexity Reduction `[minor]` + +Flagging overcomplicated solutions when simpler alternatives or existing infrastructure exist. + +- CHECK: Existing infrastructure is not being reimplemented (raw Task vs CancellationTokenSource pattern) +- CHECK: Predicate/filter parameters are justified — prefer direct lookup when possible +- CHECK: Abstraction layers add clear value — no wrapper classes that only delegate +- CHECK: Conditional logic can be simplified (nested if/else → single expression) + +### 17. Type Choice and Data Modeling `[moderate]` + +Correct type selection based on boxing, equality semantics, and API evolution. + +- CHECK: Struct used only when value semantics needed AND type will not be boxed frequently +- CHECK: Record types preferred over struct when value will be boxed (passed as `object`) +- CHECK: Flags enums validate that combined values are meaningful +- CHECK: Interface vs abstract class choice considers default implementations and state needs + +### 18. Trimming and AOT Compatibility `[moderate]` + +Patterns that work with .NET trimmer and NativeAOT. + +- CHECK: No `Type.GetType()`, `Activator.CreateInstance()`, or runtime reflection on trimmable types +- CHECK: `System.OperatingSystem` APIs used instead of `RuntimeInformation` for linker-friendly detection +- CHECK: XAML compilation paths produce code without runtime type resolution +- CHECK: `DynamicDependency` or `DynamicallyAccessedMembers` attributes applied when reflection is unavoidable + +### 19. CollectionView — iOS/MacCatalyst (Items2/) `[major]` + +UICollectionView-based handler. Items/ iOS code is DEPRECATED — all new iOS work targets Items2/. + +- CHECK: Changes target `Items2/` handler, NOT deprecated `Items/iOS/` +- CHECK: UICollectionView cell measurement invalidation is scoped — avoid full layout invalidation on single cell change +- CHECK: Custom UICollectionViewCell subclasses handle `MeasureInvalidated` only when MAUI controls need remeasuring +- CHECK: UICollectionViewCompositionalLayout configuration matches ItemsLayout specification +- CHECK: Don't double-copy ObjC arrays — `indexPathsForVisibleItems` already marshals via `CFArray.ArrayFromHandle`; calling `.ToArray()` on the result is wasteful +- CHECK: `MeasureFirstItem` cache must distinguish item types — grouped CV with undifferentiated cache applies GroupHeader size to all items, causing clipping +- CHECK: CollectionView inside ScrollView causes infinite layout loops on iOS due to unbounded `ContentSize` — add guards +- CHECK: Include gallery samples alongside tests for complex CV features (EmptyView, DataTemplateSelector) + +### 20. CollectionView — Android (Items/) `[major]` + +RecyclerView-based handler. This is the ONLY Android CollectionView implementation — Items2/ has NO Android code. + +- CHECK: Adapter uses range-specific notifications when INCC provides exact affected ranges; full refresh (`notifyDataSetChanged`) is valid for Reset, ambiguous indexes, and header/footer changes +- CHECK: ViewHolder recycling does not leak stale data — BindingContext updated on rebind +- CHECK: Layout manager selection (Linear, Grid, custom) matches ItemsLayout specification +- CHECK: Scroll position restoration works after adapter data changes +- CHECK: Changes go to `Items/Android/` — Items2/ has NO Android code + +### 21. CollectionView — Shared Models `[moderate]` + +Platform-independent CollectionView code: item source adapters, selection models, grouping, ItemsLayout. + +- CHECK: ObservableCollection change notifications handled correctly for Add, Remove, Replace, Move, Reset +- CHECK: Selection mode changes propagate to all platform handlers consistently +- CHECK: GroupHeaderTemplate/GroupFooterTemplate changes invalidate the correct scope +- CHECK: ItemsLayout changes trigger full handler reconfiguration, not partial updates + +### 22. Android Platform Specifics `[moderate]` + +Android-specific patterns: JNI, resources, native logging, and Glide. + +- CHECK: Store `Context` in a local before repeated use — accessing the property crosses the JNI bridge on every call +- CHECK: Android resource files have correct build action (`AndroidResource`, `EmbeddedResource`) — wrong action causes `FileNotFoundException` on Android only +- CHECK: Use `PlatformLogger` for native code logging under `src/Core/AndroidNative/`, not `android.util.Log` directly +- CHECK: When resolving Glide request managers, follow Glide's own `Activity` lookup pattern — don't add unnecessary `FragmentActivity` checks +- CHECK: New Java test projects require CI pipeline updates to execute — prefer C# device tests; if adding Java tests, include the pipeline changes + +### 23. iOS/macCatalyst Platform Specifics `[major]` + +iOS-specific patterns: reference counting, lifecycle, UIKit, and macCatalyst differences. + +- CHECK: When an iOS platform view holds a handler reference, the reference-counting GC often cannot break the cycle — use delegates, `Func<>`, or `WeakReference` patterns (see `DatePickerDelegate` proxy pattern) +- CHECK: Subscribe/unsubscribe to handler-dependent callbacks in `MovedToWindow`/removed-from-window — more reliable than constructor/dispose for iOS lifecycle +- CHECK: Store notification `UserInfo` in a local before repeated access — multiple `?.` on `notification.UserInfo` is wasteful and obscures null checks +- CHECK: Check `Handle == IntPtr.Zero` for disposed native objects — a `UICollectionView` may be disposed but not null +- CHECK: Wrap CollectionView layout callbacks in try-catch for `ObjectDisposedException`/`InvalidOperationException` — callbacks can fire after disposal +- CHECK: `UIImage.FromImage` creates a copy — if you only need to transform the existing image, modify in place when possible +- CHECK: Use `IUITextInput` interface for cursor/text range APIs across `UITextField`/`UITextView` — avoids duplicating code per concrete type + +### 24. Windows Platform Specifics `[moderate]` + +Windows/WinUI-specific patterns: Appium accessibility, WebView2, MSBuild, and theming. + +- CHECK: `BoxView` and other elements without text are invisible to Appium on WinUI — use `Label` or `AutomationProperties.Name` for elements that need test location +- CHECK: Guard null/empty collections before `.FirstOrDefault()` — on Windows, `.FirstOrDefault().ToPlatform()` on an empty `Accelerators` collection will throw +- CHECK: WebView2 assembly identity differs between WinUI, WPF, and WinForms — cannot directly share WebView2 helper code across targets +- CHECK: Prefix new MSBuild properties with `Maui` (e.g., `MauiEnableXamlLoading`) to avoid collisions with WindowsAppSdk properties +- CHECK: Apply theme per window, not to all windows — `ApplyThemeToAllWindows()` iterates redundantly (N+N-1+...+1 total for N windows) +- CHECK: Track applied state to avoid redundant theme/style work — use a per-window tracking mechanism + +### 25. Navigation & Shell `[major]` + +Shell tab switching, flyout lifecycle, and WebView URL security. + +- CHECK: Shell removes and re-adds platform views on tab switch — code that nullifies state in `DisconnectHandler` or `RemovedFromSuperview` will break on re-navigation +- CHECK: Test flyout state after window resize AND rotation as separate test methods — combined tests obscure which scenario fails +- CHECK: Split unrelated behaviors into separate tests — a test covering both "flyout-after-maximize" and "flyout-after-rotation" is actually two tests +- CHECK: Validate WebView URL mapping — local file mapping hostname should be random or scoped to prevent cross-origin file access +- CHECK: iOS "More" tab for overflow Shell items may not have standard Apple HIG behavior — verify push navigation correctness + +### 26. XAML & Bindings `[moderate]` + +Compiled bindings, source generation, and XAML compilation correctness. + +- CHECK: Compiled bindings require explicit `x:DataType` — every `{Binding}` with an explicit `Source` must have `x:DataType` on the binding or parent element; missing `x:DataType` causes runtime reflection fallback +- CHECK: Set `x:DataType` on root element when page sets `BindingContext` in code-behind +- CHECK: Don't subscribe on every `BindingContext` change in reusable views (`TemplatedCell`) — only subscribe if the BindingContext actually changed, otherwise subscriptions accumulate +- CHECK: Use `SetValue(BP, ...)` when a BindableProperty exists — source generators must use BP access, not direct property setters +- CHECK: Remove dead code from source generation — when `SkipProperties` is used, `CreateValuesVisitor` should also skip `new` instantiations for those properties +- CHECK: Markup extension recognition should be semantic — query the compilation for `IMarkupExtension` types, not just suffix matching +- CHECK: Auto-escape XML-unfriendly characters (`<`, `>`, `&&`, `||`) in XAML expression contexts — users should not need to type `>` + +### 27. Image Handling `[moderate]` + +Image source services, Glide callbacks, bitmap lifecycle, and clipping. + +- CHECK: `IImageSourceService.GetDrawableAsync` returns actual image data, not just a status — enables usage without a view (e.g., notification icons) +- CHECK: Verify Glide callback thread assumptions — `onResourceReady` is assumed to be on the main thread but this isn't documented; verify via Glide source +- CHECK: Clean up bitmaps on overlay add/remove cycles — disposal without a reload path causes blank overlays +- CHECK: Inner vs outer corner radius for clipping — `RoundRectangle` clip inside a `Border` uses the inner radius, not the outer border radius; outer value leaves visible gaps + +### 28. Gestures `[moderate]` + +Tap/click semantics, precondition verification, and span calculations. + +- CHECK: Use `Tap` over `Click` in UI tests for mobile platforms — `Click` may not convert to `Tap` on all platforms +- CHECK: Gesture tests must verify their precondition — a test for "GetPosition returns correct coordinates" must confirm the element was actually tapped; untappable elements make the test pass trivially +- CHECK: Span tap region calculation across multiple lines — the `CGRect` for each `Span` in `FormattedString` is incorrect when text wraps (inherited from Xamarin.Forms) + +### 29. Build & MSBuild `[moderate]` + +NuGet feed security, build task dependencies, feature flags, and auto-generated files. + +- CHECK: Use `dotnet-public` feed — adding arbitrary third-party feeds creates dependency confusion risk; new package sources require approval +- CHECK: Build tasks (`Controls.Build.Tasks.csproj`) cannot depend on optional NuGet packages like Maps — only core assemblies +- CHECK: Feature flag properties belong in `src/Core` (`Microsoft.Maui.dll`) — don't scatter across Controls or platform assemblies +- CHECK: Document feature switch breakage and alternatives — which APIs break when disabled, what users should do instead +- CHECK: NuGet vs workload import timing — moving MSBuild targets between them changes relative import order; test: install VS → new project → restore → build +- CHECK: Never commit `cgmanifest.json` or `templatestrings.json` — auto-generated during CI + +### 30. Accessibility `[moderate]` + +Font scaling, WinUI accessible elements, and property propagation. + +- CHECK: Don't disable font scaling globally via implicit styles — "Rather have an ugly app that a partially blind person can use instead of a beautiful one they can't" +- CHECK: Verify `AutomationProperties` propagate to the native accessibility tree — broken binding silently removes accessibility + +--- + +## What NOT to Flag + +Do not waste reviewer time on these: + +| Category | Why | +|----------|-----| +| **Style/formatting** | CI enforces via `dotnet format`. | +| **Missing XML docs on non-public APIs** | Not required by MAUI convention. | +| **Test naming preferences** | Unless names are genuinely misleading. | +| **`var` vs explicit types** | Project allows both; consistency within a file is sufficient. | +| **Micro-optimizations in cold paths** | Readability wins unless profiling proves it's a hot path. | +| **Single-use LINQ vs foreach** | Either is fine; don't bikeshed. | +| **Comment style** | Only flag if a comment is factually wrong or stale. | +| **PR commit count/squash** | That's the author's workflow choice. | + +--- + +## Dimension Routing + +Map each changed file against this table to determine which dimensions to activate. + +### Core Framework + +| Path Pattern | Dimensions | Platform | +|---|---|---| +| `src/Core/src/Layouts/**` | Layout Measure-Arrange, Performance-Critical Path, Logic and Correctness | all | +| `src/Core/src/Handlers/**` | Handler Mapper and Property Patterns, Public API Surface, Architectural Layer | all | +| `src/Core/src/Platform/Android/**` | Memory Leak Prevention, Async and Threading, Android Platform | android | +| `src/Core/src/Platform/iOS/**` | Safe Area, Performance-Critical Path, Memory Leak, iOS/MacCatalyst Platform | ios+maccatalyst | +| `src/Core/src/Platform/Windows/**` | Native Defaults Preservation, Async and Threading, Windows Platform | windows | + +### CollectionView + +| Path Pattern | Dimensions | Platform | +|---|---|---| +| `src/Controls/src/Core/Handlers/Items/Android/**`, `Items/*.Android.cs` | CollectionView Android, Performance, Memory Leak | android | +| `src/Controls/src/Core/Handlers/Items/*.Windows.cs` | CollectionView Shared Models, Native Defaults Preservation | windows | + +| `src/Controls/src/Core/Handlers/Items2/**` | CollectionView iOS/MacCatalyst, Layout, Memory Leak | ios+maccatalyst | +| `src/Controls/src/Core/Handlers/Items/iOS/**`, `Items/*.iOS.cs` | CollectionView iOS *(DEPRECATED — flag if new work)* | ios+maccatalyst | +| `src/Controls/src/Core/Items/*.cs` | CollectionView Shared Models, Backward Compatibility, Regression | all | + +### Controls — Handlers & Navigation + +| Path Pattern | Dimensions | Platform | +|---|---|---| +| `src/Controls/src/Core/Handlers/**` (non-Items) | Handler Mapper, Null Safety, Cross-Platform Consistency | all | +| `src/Controls/src/Core/Shell/**`, `src/Controls/src/Core/Handlers/Shell/**` | Navigation & Shell, Logic and Correctness, Regression Prevention | all | +| `src/Controls/src/Core/{View,Page,Layout,VisualElement,Element}/**` | Public API Surface, Architectural Layer, Backward Compatibility | all | +| `src/Controls/src/Core/*Gesture*/**` | Gestures, Logic and Correctness | all | +| `src/Controls/src/Core/Image*/**`, `src/Core/src/ImageSources/**` | Image Handling, Performance-Critical Path | all | +| Any file touching `AutomationProperties`, `SemanticProperties` | Accessibility, Cross-Platform Consistency | all | + +### XAML, Bindings & Source Generation + +| Path Pattern | Dimensions | Platform | +|---|---|---| +| `src/Controls/src/Xaml/**` | XAML & Bindings, Trimming/AOT | all | +| `src/Controls/src/BindingSourceGen/**`, `src/Controls/src/SourceGen/**` | XAML & Bindings, Trimming/AOT, Public API Surface | all | + +### Build & Engineering + +| Path Pattern | Dimensions | Platform | +|---|---|---| +| `eng/**`, `src/Controls/src/Build.Tasks/**` | Build & MSBuild, Regression Prevention | all | + +### Platform Detection + +| Extension/Directory | Platform | +|---|---| +| `*.Android.cs`, `*.android.cs`, `**/Platform/Android/**`, `**/Platforms/Android/**` | android | +| `*.iOS.cs`, `*.ios.cs`, `**/Platform/iOS/**`, `**/Platforms/iOS/**` | ios + maccatalyst | +| `*.MacCatalyst.cs`, `*.maccatalyst.cs`, `**/Platform/MacCatalyst/**`, `**/Platforms/MacCatalyst/**` | maccatalyst only | +| `*.Windows.cs`, `*.windows.cs`, `**/Platform/Windows/**`, `**/Platforms/Windows/**` | windows | + +### Always-Active Dimensions + +These apply regardless of file paths: Logic and Correctness, Regression Prevention, Complexity Reduction. + +### Conditional Dimensions + +| Dimension | Trigger | +|---|---| +| Public API Surface | Adds/removes `public` members or modifies `PublicAPI.Unshipped.txt` | +| Trimming/AOT | Uses reflection, `Type.GetType`, or `Activator.CreateInstance` | +| Backward Compatibility | Changes defaults, removes APIs, or touches Compatibility/ | + +--- + +## Review Workflow + +### Wave 0 — Build Briefing Pack + +1. Read PR diff (`gh pr diff`) and list changed files — form your own assessment BEFORE reading PR description (independence-first) +2. Map changed files to dimensions using the routing table above +3. Identify affected platforms from file paths using the platform detection table above +4. THEN read the PR description and linked issues for design intent — compare with your independent assessment +5. Read existing PR review comments to identify feedback already given — avoid duplicating +6. If a changed file does not map to any dimension, still scan it for Principles 1–8 + +### Wave 1 — Find (parallel sub-agents, batches of 6) + +For each activated dimension, launch a sub-agent. The sub-agent: +1. Walks every changed hunk relevant to that dimension +2. Evaluates each CHECK rule against the diff +3. **Every finding MUST have a file path.** Try hard to associate to a specific line. Priority order: + - `file:exact_line` — the specific line where the issue manifests (strongly preferred) + - `file:1` — when the issue is about the file but no single line captures it (e.g., missing import, structural concern) + - Text fallback — **only** when the finding genuinely cannot be associated with any file in the diff (e.g., "this PR is missing tests entirely"). This is the worst-case fallback, not a convenience option. +4. Appends findings to the configured findings JSON (default `inline-findings.json`). Only returns text to the top-level agent if file association truly failed. +5. Returns a count: "N inline findings written" (and if any text fallbacks: "M could not be placed on a file") + +**Threshold**: only record findings with a concrete failing scenario. Stylistic preferences are not findings. + +Run sub-agents in parallel batches of 6 dimensions at a time. + +### Wave 2 — Validate (prove or disprove each finding) + +For each potential finding from Wave 1: +1. Read surrounding context (not just the diff hunk) to check if the issue is already handled +2. Check if tests in the PR cover the scenario +3. Check git blame to see if the pattern is intentional +4. Discard findings that cannot survive validation — false positives erode trust + +**Severity assignment**: +- `critical` — data loss, crash, infinite loop, security issue +- `major` — incorrect behavior visible to users, memory leak, performance regression on hot path +- `moderate` — suboptimal pattern, missing edge case, API design concern +- `minor` — style, simplification opportunity, documentation gap + +### Wave 3 — Record and Post Findings + +**Always write the findings file** — every finding that can be associated with a file+line goes here. Try hard to associate feedback to a specific location. + +**Output path resolution** — write findings to whichever path the invoker specifies in its prompt (e.g. `OUTPUT_FINDINGS_PATH=...`, `outputPath: ...`, or any equivalent explicit instruction). If the invoker does not specify a path, default to `CustomAgentLogsTmp/PRState/{PR}/PRAgent/inline-findings.json`. This lets internal callers (e.g. `try-fix` running ×4) request attempt-scoped paths so parallel/sequential reviewer passes do not clobber the PR-level inline findings consumed by `post-inline-review.ps1`. + +```json +[ + { + "path": "src/Core/src/Handlers/ScrollView/ScrollViewHandler.iOS.cs", + "line": 42, + "body": "**[major] Layout Measure-Arrange** — Content measured with unconstrained height but arranged with bounded height. Concrete scenario: ScrollView inside a Grid with Star row height." + } +] +``` + +Each entry has exactly 3 fields matching the GitHub Pull Request Review API: +- **`path`** (string) — file relative to repo root, must exist in the PR diff +- **`line`** (integer ≥ 1) — line number **in the file on the PR branch** (right side of the diff). Must be a line that appears in the diff — the GitHub API rejects lines not in the diff with a 422 error. Use line 1 only as a fallback for file-level concerns. +- **`body`** (string) — the comment text. Embed severity and dimension in the text: `**[severity] Dimension** — description` + +Rules: +- Group related findings on adjacent lines into a single entry +- Limit to ≤15 findings — prioritize by severity +- Exclude findings already present in existing PR comments (checked in Wave 0 step 5) + +**After writing, validate the JSON.** Read back the file, verify it parses as a JSON array, and check every entry has `path` (string), `line` (integer ≥ 1), and `body` (string). If validation fails, fix the file and re-validate. + +**Text fallback** — absolute last resort, only when no file in the diff can carry the finding. If you can name even one file the concern applies to, use `file:1` instead. + +The sole output of this agent is the JSON findings file (at the invoker-specified or default path). There is no text return, no `.md` output, no dimension summary table. Each finding carries its dimension and severity in the `body` field — that is the complete record. + +--- + +## Operational Notes + +- **CollectionView handler detection**: Items/ is the active handler for Android+Windows. Items2/ is the active handler for iOS/MacCatalyst. Items/ also contains deprecated iOS files (`*.iOS.cs`) — only modify those for legacy maintenance. Never suggest "also fix in Items2/" for Android code or vice versa. See `collectionview-handler-detection.instructions.md` for full mapping. +- **File extension semantics**: Both lowercase and PascalCase forms exist (`.ios.cs`/`.iOS.cs`). The iOS form compiles for both iOS AND MacCatalyst. The MacCatalyst form compiles for MacCatalyst only. Both compile for MacCatalyst builds when both exist. diff --git a/.github/instructions/collectionview-android.instructions.md b/.github/instructions/collectionview-android.instructions.md new file mode 100644 index 000000000000..1c7e53e88636 --- /dev/null +++ b/.github/instructions/collectionview-android.instructions.md @@ -0,0 +1,32 @@ +--- +applyTo: + - "src/Controls/src/Core/Handlers/Items/Android/**" + - "src/Controls/src/Core/Handlers/Items/*.Android.cs" + - "src/Controls/src/Core/Handlers/Items/*.android.cs" +--- +# CollectionView — Android (Items/ Handler) + +> Items/ is the sole Android handler — see `collectionview-handler-detection.instructions.md` for the full platform→handler mapping. + +## RecyclerView Adapter Patterns +- Use range-specific notifications (`NotifyItemRangeInserted`, `NotifyItemRangeRemoved`, `NotifyItemRangeChanged`) when INCC semantics provide exact affected ranges — prefer these over `NotifyDataSetChanged` for preserving scroll position and animations +- Full refresh via `NotifyDataSetChanged` is valid for `Reset` actions, ambiguous index cases, and header/footer template changes +- Handle all `ObservableCollection` change actions: Add, Remove, Replace, Move, Reset +- On `Reset`, recalculate adapter state from scratch — do not assume incremental consistency + +## ViewHolder Recycling +- `BindingContext` MUST be updated on every rebind — stale data from a previous holder is a common source of visual glitches +- Do not store item-specific state in the ViewHolder outside of `BindViewHolder` — recycled holders carry state from previous items +- Dispose and recreate platform views only when the template changes, not on every rebind + +## Layout Manager +- Select layout manager (Linear, Grid, custom) based on `ItemsLayout` specification — do not hardcode +- `ItemsLayout` property changes require full layout manager replacement, not partial reconfiguration +- Account for Android pixel rounding in item measurement — fractional dp values cause 1px gaps + +## Memory and Lifecycle +- Unsubscribe from `ScrollChange` and adapter observers in `DisconnectHandler` — do NOT call Dispose on platform objects +- Scroll position restoration after adapter data changes must handle empty-collection edge case + +## Regression Patterns +- Test across empty collection, single item, many items, and with grouping — a fix for one layout scenario routinely breaks another diff --git a/.github/instructions/collectionview-ios.instructions.md b/.github/instructions/collectionview-ios.instructions.md new file mode 100644 index 000000000000..3c7ac2911020 --- /dev/null +++ b/.github/instructions/collectionview-ios.instructions.md @@ -0,0 +1,34 @@ +--- +applyTo: + - "src/Controls/src/Core/Handlers/Items2/**" + - "src/Controls/src/Core/Handlers/Items/iOS/**" + - "src/Controls/src/Core/Handlers/Items/*.iOS.cs" + - "src/Controls/src/Core/Handlers/Items/*.ios.cs" +--- +# CollectionView — iOS/MacCatalyst (Items2/ Handler) + +> New iOS/MacCatalyst work targets Items2/. Items/iOS/ is deprecated. See `collectionview-handler-detection.instructions.md` for the full platform→handler mapping. + +## UICollectionView Cell Measurement +- Scope cell layout invalidation to the affected cell — avoid `InvalidateLayout()` on the entire collection for single-cell changes +- Custom `UICollectionViewCell` subclasses should handle `MeasureInvalidated` only when the hosted MAUI control actually needs remeasuring +- Cell sizing must stay in sync between the measure pass and the layout pass — out-of-sync causes visual glitches + +## UICollectionViewCompositionalLayout +- Layout configuration must match the `ItemsLayout` specification (Linear, Grid, or custom) +- `ItemsLayout` property changes require full layout reconfiguration — partial updates leave stale section configuration +- Group header/footer template changes must invalidate the correct section scope, not the entire layout + +## Memory Management +- Use static callback patterns to avoid retain cycles between cells and their hosting handler +- Remove `NSNotificationCenter` observers in `DisconnectHandler` +- Weak references for long-lived observers of short-lived cells — cells are recycled and reused + +## Regression Patterns +- Test across empty collection, single item, many items, and with grouping — a fix for one layout scenario routinely breaks another + +## Items/ iOS (Deprecated) +- Files in `Handlers/Items/*.iOS.cs` are deprecated — prefer Items2/ for new work +- Only modify Items/ iOS code for explicit legacy maintenance or backward-compatibility fixes + +> **Platform file extension rules** (`.ios.cs` vs `.maccatalyst.cs` compilation targets) are defined in `copilot-instructions.md` § Platform-Specific File Extensions. See also `collectionview-handler-detection.instructions.md` for which handler directory to target per platform. diff --git a/.github/instructions/collectionview-windows.instructions.md b/.github/instructions/collectionview-windows.instructions.md new file mode 100644 index 000000000000..a9eff1612549 --- /dev/null +++ b/.github/instructions/collectionview-windows.instructions.md @@ -0,0 +1,26 @@ +--- +applyTo: + - "src/Controls/src/Core/Handlers/Items/*.Windows.cs" + - "src/Controls/src/Core/Handlers/Items/*.windows.cs" +--- +# CollectionView — Windows (Items/ Handler) + +Items/ is the **ONLY** Windows CollectionView implementation. Items2/ has NO Windows code. + +## WinUI ListView/ItemsRepeater Patterns +- Preserve WinUI XAML styles applied via native theming — clearing a MAUI property must restore the style-applied value, not a hardcoded default +- `double.NaN` is the WinUI convention for unconstrained dimensions — do not confuse with MAUI's `double.PositiveInfinity` +- Use `DispatcherQueue.TryEnqueue` for deferred UI thread work — do not use `Dispatcher.BeginInvoke` + +## Data Source and Change Notifications +- Handle all `ObservableCollection` change actions (Add, Remove, Replace, Move, Reset) with range-scoped updates +- Avoid full source refresh (`NotifyDataSetChanged` equivalent) — it kills selection state and scroll position +- Selection mode changes must propagate correctly to the native `SelectionMode` property + +## Layout Configuration +- `ItemsLayout` changes require reconfiguration of the underlying panel (e.g., `ItemsWrapGrid`, `ItemsStackPanel`) +- Verify that `ItemsLayout.Span` for grid layouts maps correctly to WinUI's `MaximumRowsOrColumns` + +## Cross-Platform Consistency +- Default values for control properties must produce the same visual result as Android and iOS +- Event firing order (selection changed, scrolled) should match other platforms for the same user interaction diff --git a/.github/instructions/handler-patterns.instructions.md b/.github/instructions/handler-patterns.instructions.md new file mode 100644 index 000000000000..986d9d8e8e9c --- /dev/null +++ b/.github/instructions/handler-patterns.instructions.md @@ -0,0 +1,36 @@ +--- +applyTo: + - "src/Core/src/Handlers/**" + - "src/Controls/src/Core/Handlers/**" +--- +# Handler Mapper and Property Patterns + +## Property Update Flow +- Property updates MUST go through `Handler.UpdateValue(nameof(Property))` — never call mapper methods directly +- Direct calls bypass user-registered `AppendToMapping`/`PrependToMapping` customizations +- Map dependencies before dependents — if property B reads property A, A's mapper must run first +- `CommandMapper` entries return void and use the `(handler, view, args)` signature + +## Lifecycle Management +- **ConnectHandler**: Register listeners, subscribe to events, capture native defaults BEFORE applying cross-platform properties +- **DisconnectHandler**: Unsubscribe all events, dispose platform resources, null out references +- Call `base.ConnectHandler`/`base.DisconnectHandler` — base class performs platform hookup/teardown (NOT mapper initialization, which happens in `SetVirtualView`) + +## Null Safety in Callbacks +- Null-check `VirtualView` before access in every mapper method and platform callback — it is null during disconnect +- Validate `MauiContext` before use — throw `InvalidOperationException` with descriptive message if null +- After async operations, verify the handler is still connected before applying results + +## Native Defaults Preservation +- Capture native default values (colors, fonts, styles) in `ConnectHandler` BEFORE any cross-platform property is applied +- Clearing a cross-platform property (setting to null/default) must restore the captured native default, not a hardcoded fallback +- On Windows, preserve WinUI XAML style-applied values; on Android, cache theme-inherited drawables; on iOS, capture UIAppearance defaults + +## Mapper Extensibility +- When extending existing mappers, ensure the base mapper chain is called — do not silently replace +- Static mapper methods should be `public static` to enable platform-specific overrides +- Use `nameof()` for property keys — avoid magic strings + +## Fire-and-Forget Async +- Use `.FireAndForget(handler)` for async operations in mapper methods — never use bare `async void` +- The `FireAndForget` overload accepting a handler logs exceptions through the handler's service provider diff --git a/.github/instructions/layout-system.instructions.md b/.github/instructions/layout-system.instructions.md new file mode 100644 index 000000000000..6959fd540f3a --- /dev/null +++ b/.github/instructions/layout-system.instructions.md @@ -0,0 +1,30 @@ +--- +applyTo: + - "src/Core/src/Layouts/**" + - "src/Controls/src/Core/Layout/**" + - "src/Core/src/Handlers/Layout/**" +--- +# Layout System Rules + +## Measure/Arrange Contract +- `Measure(widthConstraint, heightConstraint)` returns the desired size — it must not mutate layout state or trigger side effects +- `ArrangeChildren(bounds)` positions children within the given bounds — it must respect the size returned from `Measure`, not compute independently +- A child measured with `widthConstraint=200` must not be arranged with `width=300` — constraints must stay consistent across passes +- Subtract padding, margin, and border thickness from constraints BEFORE passing to children + +## Constraint Propagation +- Stack layouts pass `double.PositiveInfinity` along the stacking axis and the parent constraint along the cross axis +- Grid cells compute per-cell constraints from column/row definitions — do not pass the full grid constraint to each child +- `MeasureContent` helpers on `IContentView` handle inset subtraction — use them instead of manual arithmetic +- On Windows, `double.NaN` represents unconstrained dimensions (WinUI convention) — do not confuse with `double.PositiveInfinity` (MAUI convention) + +## Infinite Loop Avoidance +- Never create circular dependencies where child size depends on parent AND parent size depends on child +- Layout invalidation (`InvalidateMeasure`) must not re-trigger during an active measure pass +- ScrollView content must always be re-measured on layout trigger — do not aggressively cache child measurements in scrollable containers + +## Performance on Hot Paths + +> Layout measure/arrange methods are hot paths. All rules from `performance-hotpaths.instructions.md` apply — no LINQ, closures, or allocations. Additionally for layout: +- Cache expensive computations (e.g., `GridStructure`) and invalidate only when inputs change +- Bindable property change handlers should skip layout invalidation when the value has not actually changed diff --git a/.github/instructions/performance-hotpaths.instructions.md b/.github/instructions/performance-hotpaths.instructions.md new file mode 100644 index 000000000000..11632fb978b1 --- /dev/null +++ b/.github/instructions/performance-hotpaths.instructions.md @@ -0,0 +1,34 @@ +--- +applyTo: + - "src/Core/src/Layouts/**" + - "src/Core/src/Platform/**" + - "src/Controls/src/Core/Handlers/Items/**" + - "src/Controls/src/Core/Handlers/Items2/**" + - "src/Controls/src/Core/ScrollView/**" +--- +# Performance-Critical Path Rules + +> **Scope rationale**: globs target the actual hot paths — layout measure/arrange, +> platform scroll/touch callbacks, CollectionView/CarouselView (Items + Items2) +> recycling, and ScrollView. The full handler tree is intentionally NOT included; +> most handlers (Button, DatePicker, CheckBox, …) are not hot paths and don't need +> these constraints. If you're working on a handler that IS allocation-sensitive +> (image decoding, animation tick, etc.), apply these rules anyway. + +## Hot Paths in MAUI +Measure/arrange cycles, scrolling callbacks, binding propagation, and property change notifications are called at high frequency. All rules below apply to code on these paths. + +## Allocation Avoidance +- No LINQ methods (`.Where`, `.Select`, `.FirstOrDefault`, `.ToList`) — use indexed `for` loops +- No closures or lambdas that capture variables — these allocate a compiler-generated class per invocation +- No string concatenation or interpolation — use `StringBuilder` or pre-allocated strings if logging is required +- Prefer `Count` + indexer over `IEnumerable` iteration to avoid enumerator allocation + +## Caching and Invalidation +- Cache results of expensive computations called multiple times per layout pass +- Invalidate caches when inputs change — stale caches cause incorrect layout +- Skip redundant work: if a property's new value equals the old value, do not trigger layout invalidation or re-render + +## Collection Iteration +- When the source implements `IList` or `IReadOnlyList`, use `for (int i = 0; i < list.Count; i++)` instead of `foreach` +- `ObservableCollection` change handlers should process only the affected range, not re-enumerate the entire collection diff --git a/.github/instructions/public-api.instructions.md b/.github/instructions/public-api.instructions.md new file mode 100644 index 000000000000..3edd33ba70d0 --- /dev/null +++ b/.github/instructions/public-api.instructions.md @@ -0,0 +1,36 @@ +--- +applyTo: + - "**/PublicAPI.Unshipped.txt" + - "src/Core/src/**/*.cs" + - "src/Controls/src/**/*.cs" + - "src/Essentials/src/**/*.cs" +--- +# Public API Surface Design + +> **Activation guard**: only apply this guidance when the diff actually changes +> public API surface — `public`/`protected` types or members, interface +> definitions, builder/extension methods on public types, `[Obsolete]` markers, +> or `PublicAPI.*.txt` entries. The broad `.cs` globs exist so this guidance +> loads at the moment of API design (writing `public class Foo` in `Button.cs`), +> not just when the analyzer-generated `Unshipped.txt` is updated afterward. +> If the diff only changes internals or implementation details, ignore. + +## API Addition Rules +- New public APIs must have clear, demonstrated use cases — no speculative additions +- API naming must follow .NET design guidelines and be consistent with existing MAUI patterns +- Interfaces belong at `IView`/`IElement` level when behavior is cross-cutting — do not duplicate per-control + +## PublicAPI.Unshipped.txt +- Entries must exactly match the actual API shape (namespace, type, member signature) + +> For PublicAPI.Unshipped.txt file management workflow (never disable analyzers, `dotnet format analyzers`, revert-then-add pattern), see `copilot-instructions.md` § PublicAPI.Unshipped.txt File Management. + +## Obsolescence and Removal +- Deprecated APIs must go through `[Obsolete("message")]` with migration guidance before removal +- Include the replacement API or pattern in the obsolete message +- Breaking changes require explicit design justification documented in the PR + +## Visibility Decisions +- Default to `internal` — make `public` only when external consumers need access +- `protected` members in unsealed types are part of the public API surface — treat with same rigor +- Use `[EditorBrowsable(EditorBrowsableState.Never)]` for APIs that must be public for technical reasons but should not appear in IntelliSense diff --git a/.github/instructions/threading-async.instructions.md b/.github/instructions/threading-async.instructions.md new file mode 100644 index 000000000000..b9aeeb0282ce --- /dev/null +++ b/.github/instructions/threading-async.instructions.md @@ -0,0 +1,34 @@ +--- +applyTo: + - "**/*.Android.cs" + - "**/*.android.cs" + - "**/*.iOS.cs" + - "**/*.ios.cs" + - "**/*.Windows.cs" + - "**/*.windows.cs" + - "**/Platform/**" + - "**/Platforms/**" +--- +# Threading and Async Patterns + +## UI Thread Dispatch +- Platform view modifications MUST happen on the UI thread +- **Android**: `platformView.Post(() => { })` or `Looper.MainLooper` for thread checks +- **iOS/MacCatalyst**: `MainThread.BeginInvokeOnMainThread()` or `DispatchQueue.MainQueue` +- **Windows**: `DispatcherQueue.TryEnqueue()` — be aware of COM threading apartment model + +## Async Handler Operations +- Use `.FireAndForget(handler)` for async work in mapper methods — never bare `async void` +- After `await`, verify the handler is still connected (`VirtualView != null`) before applying results +- Thread `CancellationToken` through long-running operations and check at appropriate yield points + +## Race Condition Prevention +- Concurrent access to shared state must use `lock`, `Interlocked`, or immutable patterns +- Image loading and other async pipelines must cancel in-flight operations when the source changes +- Guard against stale callbacks — platform callbacks may fire after `DisconnectHandler` + +## Platform-Specific Patterns +- **Android**: API-level checks use `Build.VERSION.SdkInt` comparison, not version string parsing +- **iOS**: Use `System.OperatingSystem.IsIOSVersionAtLeast()` for linker-friendly runtime checks +- **Windows**: WinUI version checks may be needed for features in specific Windows App SDK versions +- Use `System.OperatingSystem` APIs over `RuntimeInformation` — they are trimmer/AOT-friendly diff --git a/.github/scripts/Review-PR.ps1 b/.github/scripts/Review-PR.ps1 index acd7de121f0e..50b7d622e6b9 100644 --- a/.github/scripts/Review-PR.ps1 +++ b/.github/scripts/Review-PR.ps1 @@ -7,7 +7,8 @@ Step 0: Branch setup - Create review branch from main, merge PR squashed Step 1: Gate - Run test verification directly (verify-tests-fail.ps1) - Step 2: pr-review skill - 3-phase review (Pre-Flight, Try-Fix, Report) + Step 2: Multi-candidate review - Pre-Flight, then PARALLEL (expert-reviewer eval of PR + Try-Fix×4), + then Report compares all candidates and writes winner.json Step 3: Post AI Summary - Directly runs posting scripts Step 4: Apply labels - Apply agent labels based on review results @@ -298,7 +299,10 @@ function Invoke-CopilotStep { } # Use JSON output format to stream live progress of agent activity. - & copilot -p $Prompt --allow-all --output-format json 2>&1 | ForEach-Object { + # Model is overridable via $env:COPILOT_REVIEW_MODEL so contributors without internal-model access + # can run this script (e.g., with 'claude-opus-4.6' or 'claude-sonnet-4.6'). + $copilotModel = if ($env:COPILOT_REVIEW_MODEL) { $env:COPILOT_REVIEW_MODEL } else { 'claude-opus-4.7-1m-internal' } + & copilot -p $Prompt --allow-all --output-format json --model $copilotModel 2>&1 | ForEach-Object { $line = $_.ToString() try { $event = $line | ConvertFrom-Json -ErrorAction Stop @@ -391,13 +395,13 @@ function Invoke-CopilotStep { } } 'result' { - # Final stats - $usage = $event.data.usage + # Final stats — note: 'result' is a top-level event with no 'data' wrapper. + $usage = $event.usage if ($usage) { $elapsed = $stopwatch.Elapsed.ToString("mm\:ss") $apiMs = if ($usage.totalApiDurationMs) { [math]::Round($usage.totalApiDurationMs / 1000, 1) } else { "?" } $changes = $usage.codeChanges - $filesChanged = if ($changes -and $changes.filesModified) { $changes.filesModified.Count } else { 0 } + $filesChanged = if ($changes -and $changes.filesModified) { @($changes.filesModified).Count } else { 0 } $linesAdded = if ($changes) { $changes.linesAdded } else { 0 } $linesRemoved = if ($changes) { $changes.linesRemoved } else { 0 } @@ -547,7 +551,12 @@ for ($gateAttempt = 1; $gateAttempt -le $maxGateAttempts; $gateAttempt++) { } # Clear previous attempt's report so a crash mid-run doesn't leak its classification into this one. Remove-Item $gateContentFile -Force -ErrorAction SilentlyContinue - $gateOutput = & pwsh -NoProfile -File "$verifyScript" -Platform $gatePlatform -PRNumber $PRNumber -RequireFullVerification 2>&1 + # Note: -RequireFullVerification is intentionally OMITTED. The verify script + # auto-detects fix files from the diff; if there are none (e.g., a test-only + # PR like a regression repro), it falls back to "verify failure only" mode + # and reports whether the new tests fail without any fix. Passing the flag + # would force the script to error out for those PRs. + $gateOutput = & pwsh -NoProfile -File "$verifyScript" -Platform $gatePlatform -PRNumber $PRNumber 2>&1 $gateExitCode = $LASTEXITCODE $gateOutput | ForEach-Object { Write-Host " $_" } @@ -600,7 +609,74 @@ Write-Host " 📁 Gate result: $gateResult" -ForegroundColor $gateColor # Copy the verification report to gate/content.md (always overwrite — the report is the source of truth) $verificationReport = Join-Path $gateOutputDir "verify-tests-fail/verification-report.md" # Capture last meaningful lines from gate output for fallback diagnostics -$gateLogTail = @($gateOutput | ForEach-Object { $_.ToString() } | Where-Object { $_ -match '\S' } | Select-Object -Last 20) -join "`n" +$gateLogTail = @($gateOutput | ForEach-Object { $_.ToString() } | Where-Object { $_ -match '\S' } | Select-Object -Last 60) -join "`n" + +# ─── Improvement #1: build rich fallback diagnostics for the silent-failure case ─── +# When verify-tests-fail.ps1 aborts before writing its report, the original fallback +# emitted just "Gate Result: FAILED" + an empty
block. Capture extra signal +# so reviewers and downstream agents can act on it. +function Get-GateFallbackDetails { + param([string]$Tail, [int]$ExitCode, [string]$VerifyDir, [string]$ReviewedPlatform) + + $sections = @() + + $sections += "**Exit code:** ``$ExitCode``" + + # Surface auto-detected tests / fix files from the verify script's stdout + # so reviewers can tell whether detection failed vs. the test run itself. + $detected = @{} + foreach ($line in ($Tail -split "`n")) { + if ($line -match '^\s*Detected test type:\s*(\S+)') { $detected['type'] = $Matches[1] } + elseif ($line -match '^\s*Test filter:\s*(\S+)') { $detected['filter'] = $Matches[1] } + elseif ($line -match '^\s*Fix files \((\d+)\):') { $detected['fixCount'] = $Matches[1] } + elseif ($line -match '^\s*Merge base:\s*(\S+)') { $detected['mergeBase'] = $Matches[1] } + } + if ($detected.Count -gt 0) { + $items = @() + if ($detected.ContainsKey('type')) { $items += "- Test type: ``$($detected['type'])``" } + if ($detected.ContainsKey('filter')) { $items += "- Test filter: ``$($detected['filter'])``" } + if ($detected.ContainsKey('fixCount')) { $items += "- Fix files detected: $($detected['fixCount'])" } + if ($detected.ContainsKey('mergeBase')) { $items += "- Merge base: ``$($detected['mergeBase'])``" } + $sections += "**Auto-detected:**`n" + ($items -join "`n") + } + + # Heuristic classification — make the cause actionable instead of leaving the + # reader to grep stderr. + $likely = @() + if ($Tail -match '(?i)Could not auto-detect PR number|no tests detected|0 test\(s\) detected') { + $likely += "Test detection failed — no runnable tests were found in the PR diff." + } + # Match coded build errors (CS, MSB, NU, MAUI, NETSDK, XA, etc.) without false-positiving + # on lines like "MSBUILD output: 0 error(s)". The general form `error ` covers + # compiler, MSBuild, NuGet restore, MAUI analyzer, .NET SDK, Android packaging diagnostics. + if ($Tail -match '(?i)build failed|\berror\s+[A-Z]{2,}\d+\b') { + $likely += "Build error before any test could run." + } + if ($Tail -match '(?i)emulator.*(?:timeout|failed|not.found)|adb.*(?:server|crashed)|xharness.*(?:failed|timeout)') { + $likely += "Device/emulator setup failed (env error class)." + } + if ($Tail -match '(?i)merge.conflict|conflict.*merge.base') { + $likely += "Merge conflict prevented running the gate." + } + if ($Tail -match '(?i)NO FIX FILES DETECTED') { + $likely += "No fix files detected in the diff (PR may be test-only — should now run in failure-only mode)." + } + if ($likely.Count -gt 0) { + $sections += "**Likely cause:**`n" + (($likely | ForEach-Object { "- $_" }) -join "`n") + } + + # List artifacts under gate/verify-tests-fail/ — partial logs sometimes survive + # even when the report itself was not written. + if (Test-Path $VerifyDir) { + $files = Get-ChildItem -Path $VerifyDir -File -ErrorAction SilentlyContinue | + Sort-Object Name | ForEach-Object { "- ``$($_.Name)`` ($([math]::Round($_.Length / 1KB, 1)) KB)" } + if ($files) { + $sections += "**Artifacts written before exit:**`n" + ($files -join "`n") + } + } + + return ($sections -join "`n`n") +} if (Test-Path $verificationReport) { $reportContent = Get-Content $verificationReport -Raw -ErrorAction SilentlyContinue @@ -612,13 +688,18 @@ if (Test-Path $verificationReport) { # Report exists but has bad format — generate fallback with logs Write-Host " ⚠️ Verification report has invalid format — using fallback" -ForegroundColor Yellow $resultIcon = switch ($gateResult) { "PASSED" { "✅" } "SKIPPED" { "⚠️" } default { "❌" } } + $fallbackDetails = Get-GateFallbackDetails -Tail $gateLogTail -ExitCode $gateExitCode -VerifyDir (Join-Path $gateOutputDir "verify-tests-fail") -ReviewedPlatform $gatePlatform @" ### Gate Result: $resultIcon $gateResult **Platform:** $($gatePlatform.ToUpper()) +> ⚠️ ``verify-tests-fail.ps1`` produced an empty report. Diagnostics below. + +$fallbackDetails +
-Gate output log +Gate output log (last 60 lines) `````` $gateLogTail @@ -638,13 +719,18 @@ No tests were detected in this PR. "@ | Set-Content (Join-Path $gateOutputDir "content.md") -Encoding UTF8 } else { $resultIcon = switch ($gateResult) { "PASSED" { "✅" } default { "❌" } } + $fallbackDetails = Get-GateFallbackDetails -Tail $gateLogTail -ExitCode $gateExitCode -VerifyDir (Join-Path $gateOutputDir "verify-tests-fail") -ReviewedPlatform $gatePlatform @" ### Gate Result: $resultIcon $gateResult **Platform:** $($gatePlatform.ToUpper()) +> ⚠️ ``verify-tests-fail.ps1`` exited before writing a verification report. Diagnostics below. + +$fallbackDetails +
-Gate output log +Gate output log (last 60 lines) `````` $gateLogTail @@ -655,11 +741,8 @@ $gateLogTail } } -# Post gate result by updating (or creating) the unified AI Summary comment. -# The same script is called again in STEP 3 once the review phases finish; here -# it runs early so the PR author sees the gate outcome without waiting for the -# full review. -$postGateScript = Join-Path $PSScriptRoot "post-ai-summary-comment.ps1" +# Post gate result as a separate PR comment +$postGateScript = Join-Path $PSScriptRoot "post-gate-comment.ps1" if (Test-Path $postGateScript) { try { if ($DryRun) { @@ -668,10 +751,10 @@ if (Test-Path $postGateScript) { & $postGateScript -PRNumber $PRNumber } } catch { - Write-Host " ⚠️ Failed to post gate section (non-fatal): $_" -ForegroundColor Yellow + Write-Host " ⚠️ Failed to post gate comment (non-fatal): $_" -ForegroundColor Yellow } } else { - Write-Host " ⚠️ post-ai-summary-comment.ps1 not found" -ForegroundColor Yellow + Write-Host " ⚠️ post-gate-comment.ps1 not found" -ForegroundColor Yellow } # Apply gate result label @@ -715,7 +798,49 @@ $gateStatusForPrompt = switch ($gateResult) { } $step2Prompt = @" -Use a skill to review PR #$PRNumber. +Run a multi-candidate PR review for PR #$PRNumber using the following flow. + +## Phase 1 — Pre-Flight (context only) +Use the pr-review skill's pre-flight phase to gather context. Do NOT modify code. +Write summary to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/pre-flight/content.md``. + +## Phase 2 — Candidate generation (run BOTH branches; do not skip either) +Generate the following candidates. Each candidate is an alternative diff against the PR's base branch. Do this work in isolated worktrees / scratch copies so artifacts do NOT clobber each other. + +### Branch A — Expert reviewer evaluation of the current PR fix (in sandbox) +Use the code-review skill with the maui-expert-reviewer agent to evaluate the PR's existing fix. Apply the reviewer's actionable feedback in a sandbox copy and treat the result as a candidate named ``pr-plus-reviewer``. +- Always also write the raw inline findings to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/inline-findings.json`` (these are file:line findings against the PR's diff and feed the inline-comment posting step). +- Write candidate output to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/expert-pr-eval/content.md``. + +### Branch B — Try-Fix ×4 (ALWAYS runs — do NOT skip) +Use the pr-review skill's try-fix phase to generate FOUR independent candidate fixes (``try-fix-1`` through ``try-fix-4``). Each candidate must load domain knowledge from a different maui-expert-reviewer dimension so the candidates are diverse. +- 🚨 You MUST generate all four candidates. Do not short-circuit even if Pre-Flight or the expert eval suggests the PR is already correct. +- Write each candidate's output to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/try-fix-{N}/content.md`` (N = 1..4). +- Aggregate try-fix narrative for the AI summary comment to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/try-fix/content.md``. + +## Phase 3 — Report +The expert reviewer evaluates ALL candidates against each other: +- ``pr`` (the raw PR fix as submitted) +- ``pr-plus-reviewer`` (PR fix + reviewer feedback applied in sandbox) +- ``try-fix-1``..``try-fix-4`` +Pick the single winning candidate. +Write the comparative analysis to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/report/content.md``. + +## Phase 4 — Winner manifest (REQUIRED) +Write ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/winner.json`` with this exact schema: +``````json +{ + "schemaVersion": 1, + "winner": "pr" | "pr-plus-reviewer" | "try-fix-1" | "try-fix-2" | "try-fix-3" | "try-fix-4", + "isPRFix": true | false, + "summary": "1-3 sentence rationale for why this candidate won", + "candidateDiff": "" +} +`````` +Rules: +- ``isPRFix`` MUST be ``true`` when ``winner`` is ``pr`` or ``pr-plus-reviewer``. +- ``isPRFix`` MUST be ``false`` when ``winner`` is any ``try-fix-*``. +- When ``isPRFix`` is ``false``, ``candidateDiff`` MUST be a non-empty unified diff. Truncate at 55 KB if larger and end with a ``... [truncated]`` marker line. $platformInstruction $autonomousRules @@ -723,9 +848,6 @@ $autonomousRules **Gate result (already completed in a prior step):** $gateStatusForPrompt Do NOT re-run gate verification. The gate phase is handled separately. ⚠️ Do NOT create or overwrite ``gate/content.md`` — it is already generated by the gate script with detailed test output. - -📁 Write phase output to ``CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/{phase}/content.md`` -(phases: pre-flight, try-fix, report — NOT gate) "@ Invoke-CopilotStep -StepName "STEP 2: PR REVIEW" -Prompt $step2Prompt | Out-Null @@ -806,6 +928,138 @@ if (Test-Path $reviewScript) { Write-Host " ⚠️ post-ai-summary-comment.ps1 not found — skipping review summary" -ForegroundColor Yellow } +# Determine winning candidate (winner.json) — drives whether we post inline findings or request changes +$winnerFile = Join-Path $RepoRoot "CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/winner.json" +$winner = $null +if (Test-Path $winnerFile) { + try { + $winner = Get-Content -Raw -LiteralPath $winnerFile | ConvertFrom-Json + # Validation + $allowed = @('pr','pr-plus-reviewer','try-fix-1','try-fix-2','try-fix-3','try-fix-4') + if (-not $winner.winner -or $allowed -notcontains $winner.winner) { + Write-Host " ⚠️ winner.json has invalid 'winner' value: $($winner.winner) — falling back to PR-fix path" -ForegroundColor Yellow + $winner = $null + } elseif ($winner.winner -in @('pr','pr-plus-reviewer') -and $winner.isPRFix -ne $true) { + Write-Host " ⚠️ winner.json: '$($winner.winner)' must have isPRFix=true — overriding" -ForegroundColor Yellow + $winner.isPRFix = $true + } elseif ($winner.winner -like 'try-fix-*' -and $winner.isPRFix -ne $false) { + Write-Host " ⚠️ winner.json: '$($winner.winner)' must have isPRFix=false — overriding" -ForegroundColor Yellow + $winner.isPRFix = $false + } + if ($winner -and $winner.isPRFix -eq $false -and [string]::IsNullOrWhiteSpace($winner.candidateDiff)) { + Write-Host " ⚠️ winner.json: non-PR winner has empty candidateDiff — falling back to PR-fix path" -ForegroundColor Yellow + $winner = $null + } + if ($winner) { + Write-Host " 🏆 Winning candidate: $($winner.winner) (isPRFix=$($winner.isPRFix))" -ForegroundColor Cyan + } + } catch { + Write-Host " ⚠️ Failed to parse winner.json (non-fatal): $_ — falling back to PR-fix path" -ForegroundColor Yellow + $winner = $null + } +} else { + Write-Host " ℹ️ No winner.json — defaulting to PR-fix posting path" -ForegroundColor Gray +} + +$isPRWinner = (-not $winner) -or ($winner.isPRFix -eq $true) + +if ($isPRWinner) { + # Post inline review comments (file:line findings from expert-reviewer agent) + $inlineScript = Join-Path $summaryScriptsDir "post-inline-review.ps1" + $findingsFile = Join-Path $RepoRoot "CustomAgentLogsTmp/PRState/$PRNumber/PRAgent/inline-findings.json" + if ((Test-Path $inlineScript) -and (Test-Path $findingsFile)) { + try { + Write-Host " 📝 Posting inline review comments..." -ForegroundColor Cyan + if ($DryRun) { + & $inlineScript -PRNumber $PRNumber -FindingsFile $findingsFile -DryRun + } else { + & $inlineScript -PRNumber $PRNumber -FindingsFile $findingsFile + } + Write-Host " ✅ Inline review comments posted" -ForegroundColor Green + } catch { + Write-Host " ⚠️ Inline review posting failed (non-fatal): $_" -ForegroundColor Yellow + } + } else { + if (-not (Test-Path $findingsFile)) { + Write-Host " ℹ️ No inline findings file — agent may not have produced findings" -ForegroundColor Gray + } + } +} else { + # Non-PR candidate won — submit a REQUEST_CHANGES review with the candidate diff in the body + Write-Host " 📝 Non-PR candidate won — submitting REQUEST_CHANGES review with candidate diff..." -ForegroundColor Cyan + + $maxDiffBytes = 55KB + $diff = [string]$winner.candidateDiff + $truncated = $false + # Truncate by binary-searching the largest character count whose UTF-8 + # encoding fits within the byte budget (reserving room for the marker line). + # O(log n) and much cheaper than the previous O(n²) trim-512-and-recount loop. + $marker = "`n... [truncated]" + $markerBytes = [System.Text.Encoding]::UTF8.GetByteCount($marker) + $budget = $maxDiffBytes - $markerBytes + if ([System.Text.Encoding]::UTF8.GetByteCount($diff) -gt $maxDiffBytes) { + $lo = 0 + $hi = $diff.Length + while ($lo -lt $hi) { + $mid = [int](($lo + $hi + 1) / 2) + $bytes = [System.Text.Encoding]::UTF8.GetByteCount($diff.Substring(0, $mid)) + if ($bytes -le $budget) { $lo = $mid } else { $hi = $mid - 1 } + } + $diff = $diff.Substring(0, $lo) + $marker + $truncated = $true + } + + # Compute an outer code fence longer than any backtick run inside the diff + # (minimum 4) so the diff content cannot accidentally close the fence and + # leak into the surrounding markdown. Preserves the diff text exactly. + $maxBacktickRun = 0 + foreach ($m in [regex]::Matches($diff, '`+')) { + if ($m.Length -gt $maxBacktickRun) { $maxBacktickRun = $m.Length } + } + $fenceLen = [Math]::Max(4, $maxBacktickRun + 1) + $fence = '`' * $fenceLen + + $rationale = if ($winner.summary) { [string]$winner.summary } else { "Automated review identified a stronger candidate fix." } + $reviewBody = @" +🤖 **Automated review — alternative fix proposed** + +The expert-reviewer evaluation compared the PR fix against $($winner.winner -replace 'try-fix-','#') automatically generated candidates and selected ``$($winner.winner)`` as the strongest fix. + +**Why:** $rationale + +Please consider applying the candidate diff below (or use it as guidance). Once you push an update, this workflow will re-trigger and re-evaluate. + +
Candidate diff (``$($winner.winner)``) + +${fence}diff +$diff +$fence + +
+$( if ($truncated) { "`n_The diff was truncated to fit GitHub's review body limit._" } ) +"@ + + if ($DryRun) { + Write-Host " [DryRun] Would POST review state=REQUEST_CHANGES with body length $($reviewBody.Length)" -ForegroundColor Yellow + } else { + try { + $bodyJson = @{ body = $reviewBody; event = 'REQUEST_CHANGES' } | ConvertTo-Json -Compress -Depth 5 + $tmp = New-TemporaryFile + Set-Content -LiteralPath $tmp -Value $bodyJson -Encoding utf8 -NoNewline + $resp = & gh api -X POST "repos/dotnet/maui/pulls/$PRNumber/reviews" --input $tmp 2>&1 + Remove-Item -LiteralPath $tmp -Force -ErrorAction SilentlyContinue + if ($LASTEXITCODE -eq 0) { + Write-Host " ✅ REQUEST_CHANGES review submitted" -ForegroundColor Green + } else { + Write-Host " ⚠️ Failed to submit REQUEST_CHANGES review (non-fatal): $resp" -ForegroundColor Yellow + } + } catch { + Write-Host " ⚠️ REQUEST_CHANGES submission threw (non-fatal): $_" -ForegroundColor Yellow + } + } + Write-Host " ⏭️ Skipping inline findings (winner is not the PR fix)" -ForegroundColor Gray +} + # ═════════════════════════════════════════════════════════════════════════════ # STEP 4: Apply Labels # ═════════════════════════════════════════════════════════════════════════════ diff --git a/.github/scripts/post-inline-review.ps1 b/.github/scripts/post-inline-review.ps1 new file mode 100644 index 000000000000..e4fe45f509df --- /dev/null +++ b/.github/scripts/post-inline-review.ps1 @@ -0,0 +1,264 @@ +#!/usr/bin/env pwsh +<# +.SYNOPSIS + Posts inline review comments on a GitHub Pull Request from a JSON findings file. + +.DESCRIPTION + Reads inline-findings.json (produced by the maui-expert-reviewer agent) and posts + them as a GitHub PR review with inline file:line comments. + + Also posts review-summary.md as the review body. + + Uses the GitHub Pulls Review API to create a single review with all inline comments + attached at their exact file:line locations. + +.PARAMETER PRNumber + The pull request number (required) + +.PARAMETER FindingsFile + Path to inline-findings.json. Default: CustomAgentLogsTmp/PRState/{PRNumber}/PRAgent/inline-findings.json + +.PARAMETER SummaryFile + Path to review-summary.md. Default: CustomAgentLogsTmp/PRState/{PRNumber}/PRAgent/review-summary.md + +.PARAMETER DryRun + Print the review payload instead of posting + +.EXAMPLE + ./post-inline-review.ps1 -PRNumber 12345 + +.EXAMPLE + ./post-inline-review.ps1 -PRNumber 12345 -DryRun + +.EXAMPLE + ./post-inline-review.ps1 -PRNumber 12345 -FindingsFile /tmp/findings.json +#> + +param( + [Parameter(Mandatory = $true)] + [int]$PRNumber, + + [Parameter(Mandatory = $false)] + [string]$FindingsFile, + + [Parameter(Mandatory = $false)] + [string]$SummaryFile, + + [Parameter(Mandatory = $false)] + [switch]$DryRun +) + +$ErrorActionPreference = "Stop" + +# ============================================================================ +# RESOLVE FILE PATHS +# ============================================================================ + +$PRAgentDir = "CustomAgentLogsTmp/PRState/$PRNumber/PRAgent" +if (-not (Test-Path $PRAgentDir)) { + $repoRoot = git rev-parse --show-toplevel 2>$null + if ($repoRoot) { + $PRAgentDir = Join-Path $repoRoot "CustomAgentLogsTmp/PRState/$PRNumber/PRAgent" + } +} + +if (-not $FindingsFile) { + $FindingsFile = Join-Path $PRAgentDir "inline-findings.json" +} +if (-not $SummaryFile) { + $SummaryFile = Join-Path $PRAgentDir "review-summary.md" +} + +if (-not (Test-Path $FindingsFile)) { + Write-Host "No findings file found at: $FindingsFile" -ForegroundColor Yellow + Write-Host "Nothing to post." -ForegroundColor Yellow + exit 0 +} + +# ============================================================================ +# LOAD FINDINGS +# ============================================================================ + +Write-Host "Loading findings from: $FindingsFile" -ForegroundColor Cyan +$findings = Get-Content -Path $FindingsFile -Raw -Encoding UTF8 | ConvertFrom-Json + +if (-not $findings -or $findings.Count -eq 0) { + Write-Host "No findings to post." -ForegroundColor Green + exit 0 +} + +Write-Host " Found $($findings.Count) inline findings" -ForegroundColor Gray + +# Load summary if available +$summaryBody = "" +if (Test-Path $SummaryFile) { + $summaryBody = Get-Content -Path $SummaryFile -Raw -Encoding UTF8 + Write-Host " Loaded summary ($($summaryBody.Length) chars)" -ForegroundColor Gray +} else { + $summaryBody = "## Expert Review — $($findings.Count) findings`n`nSee inline comments for details." +} + +# ============================================================================ +# GET PR HEAD COMMIT (required by GitHub API) +# ============================================================================ + +Write-Host "Fetching PR #$PRNumber head commit..." -ForegroundColor Cyan +$prJson = gh api "repos/dotnet/maui/pulls/$PRNumber" --jq '{sha: .head.sha}' 2>&1 +if ($LASTEXITCODE -ne 0) { + throw "Failed to fetch PR #${PRNumber}: $prJson" +} +$prData = $prJson | ConvertFrom-Json +$commitSha = $prData.sha +Write-Host " HEAD: $commitSha" -ForegroundColor Gray + +# ============================================================================ +# BUILD REVIEW PAYLOAD +# ============================================================================ + +$comments = @() +foreach ($f in $findings) { + # Defense-in-depth: reject suspicious paths so a malformed/hostile finding + # cannot poison the whole review post (especially in the fallback branch + # below where the GitHub diff fetch failed and we can't cross-validate). + $p = [string]$f.path + if ([string]::IsNullOrWhiteSpace($p) -or + $p.Contains('..') -or + $p.StartsWith('/') -or + $p.StartsWith('\') -or + $p.Contains('\') -or + $p -match '[\x00-\x1F]' -or + $p -match '^[A-Za-z]:') { + Write-Host " ⚠️ Skipping finding with suspicious path: '$p'" -ForegroundColor Yellow + continue + } + + $comment = @{ + path = $p + line = [int]$f.line + body = $f.body + } + # GitHub API requires 'side' for pull request review comments + $comment['side'] = 'RIGHT' + $comments += $comment +} + +# ============================================================================ +# FILTER COMMENTS TO LINES PRESENT IN THE PR DIFF +# GitHub returns 422 "Line could not be resolved" if ANY comment targets a +# line outside the diff. Pre-validate to avoid losing the entire review. +# ============================================================================ + +Write-Host "Fetching PR diff for line validation..." -ForegroundColor Cyan +$filesJson = gh api --paginate "repos/dotnet/maui/pulls/$PRNumber/files" 2>&1 +if ($LASTEXITCODE -ne 0) { + Write-Host " ⚠️ Could not fetch PR files for validation: $filesJson" -ForegroundColor Yellow + Write-Host " Posting all findings without pre-validation." -ForegroundColor Yellow +} else { + $files = $filesJson | ConvertFrom-Json + # Build map: path -> set of new-file line numbers commentable on RIGHT side + $diffLines = @{} + foreach ($file in $files) { + $path = $file.filename + $patch = $file.patch + if (-not $patch) { continue } + $lineSet = New-Object System.Collections.Generic.HashSet[int] + $newLine = 0 + foreach ($pl in ($patch -split "`n")) { + if ($pl -match '^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@') { + $newLine = [int]$Matches[1] + continue + } + if ($pl.StartsWith('+') -and -not $pl.StartsWith('+++')) { + [void]$lineSet.Add($newLine) + $newLine++ + } elseif ($pl.StartsWith('-') -and -not $pl.StartsWith('---')) { + # deletion — does not advance new-file line + } elseif ($pl.StartsWith(' ')) { + # context — also commentable (RIGHT side) + [void]$lineSet.Add($newLine) + $newLine++ + } + } + $diffLines[$path] = $lineSet + } + + $kept = @() + $dropped = @() + foreach ($c in $comments) { + if ($diffLines.ContainsKey($c.path) -and $diffLines[$c.path].Contains([int]$c.line)) { + $kept += $c + } else { + $dropped += $c + } + } + if ($dropped.Count -gt 0) { + Write-Host " ⚠️ Dropping $($dropped.Count) finding(s) whose lines aren't in the PR diff:" -ForegroundColor Yellow + foreach ($d in $dropped) { + Write-Host " $($d.path):$($d.line)" -ForegroundColor Gray + } + } + Write-Host " ✅ $($kept.Count) of $($comments.Count) findings target lines in the diff" -ForegroundColor Gray + $comments = $kept +} + +if ($comments.Count -eq 0) { + Write-Host "No inline-commentable findings remain after diff validation. Skipping review post." -ForegroundColor Yellow + exit 0 +} + +$reviewPayload = @{ + commit_id = $commitSha + body = $summaryBody + event = "COMMENT" # Never APPROVE or REQUEST_CHANGES — that's a human decision + comments = $comments +} + +$payloadJson = $reviewPayload | ConvertTo-Json -Depth 10 + +# ============================================================================ +# DRY RUN +# ============================================================================ + +if ($DryRun) { + Write-Host "" + Write-Host "═══════════════════════════════════════════════════════" -ForegroundColor Yellow + Write-Host " DRY RUN — Review preview (not posted)" -ForegroundColor Yellow + Write-Host "═══════════════════════════════════════════════════════" -ForegroundColor Yellow + Write-Host "" + Write-Host "Summary:" -ForegroundColor Cyan + Write-Host $summaryBody + Write-Host "" + Write-Host "Inline comments ($($comments.Count)):" -ForegroundColor Cyan + foreach ($c in $comments) { + Write-Host " $($c.path):$($c.line)" -ForegroundColor White -NoNewline + Write-Host " — $($c.body.Substring(0, [Math]::Min($c.body.Length, 120)))..." -ForegroundColor Gray + } + Write-Host "" + Write-Host "═══════════════════════════════════════════════════════" -ForegroundColor Yellow + Write-Host " Payload size: $($payloadJson.Length) chars" -ForegroundColor Gray + Write-Host "═══════════════════════════════════════════════════════" -ForegroundColor Yellow + return +} + +# ============================================================================ +# POST REVIEW +# ============================================================================ + +Write-Host "Posting review with $($comments.Count) inline comments..." -ForegroundColor Cyan + +$tempFile = [System.IO.Path]::GetTempFileName() +try { + $payloadJson | Set-Content -Path $tempFile -Encoding UTF8 + + $result = gh api --method POST "repos/dotnet/maui/pulls/$PRNumber/reviews" --input $tempFile 2>&1 + if ($LASTEXITCODE -ne 0) { + throw "Failed to post review: $result" + } + + $reviewData = $result | ConvertFrom-Json + Write-Host "Review posted (ID: $($reviewData.id))" -ForegroundColor Green + Write-Host " $($comments.Count) inline comments at file:line" -ForegroundColor Gray + Write-Host " URL: $($reviewData.html_url)" -ForegroundColor Gray +} finally { + Remove-Item -Path $tempFile -Force -ErrorAction SilentlyContinue +} diff --git a/.github/scripts/shared/Detect-TestsInDiff.ps1 b/.github/scripts/shared/Detect-TestsInDiff.ps1 index 253b98e5a867..b7a141d4e034 100644 --- a/.github/scripts/shared/Detect-TestsInDiff.ps1 +++ b/.github/scripts/shared/Detect-TestsInDiff.ps1 @@ -185,6 +185,40 @@ $IgnoredFileNames = @( # Intermediate: collect test files grouped by type + test name $testGroups = @{} # Key: "Type:TestName" → Value: hashtable +# ─── Reliability fix #7: parse the actual class name from the .cs file ─── +# The previous logic derived the dotnet test filter from the *filename basename*, +# but maui's test repo uses a "category-prefix" file-naming convention where the +# filename includes a logical bucket dot the class name (e.g. +# `CarouselViewUITests.ProgrammaticPositionBounceBack.cs` containing the class +# `CarouselViewProgrammaticPositionBounceBack`). Filtering by the filename +# yielded `--filter FullyQualifiedName~CarouselViewUITests.ProgrammaticPositionBounceBack` +# which matched zero tests, and the gate marked the PR FAILED purely because of +# our auto-detection mistake. Reading the actual `public class` declaration +# from the file content is more reliable. Falls back to the filename basename +# when the file can't be read (e.g., file deleted, path unresolvable). +$RepoRootForRead = git rev-parse --show-toplevel 2>$null +function Get-ClassNameFromFile { + param([string]$RelativePath) + $candidates = @($RelativePath) + if ($RepoRootForRead) { + $candidates += (Join-Path $RepoRootForRead $RelativePath) + } + foreach ($p in $candidates) { + if (Test-Path $p) { + try { + $content = Get-Content $p -Raw -ErrorAction Stop + } catch { continue } + # Match the first non-static, non-abstract `public class XXX` or + # `public partial class XXX` declaration — only concrete classes (skip + # `abstract`/`static`) so a base test class declared above the concrete + # test class isn't picked up and turned into a non-matching test filter. + $m = [regex]::Match($content, '(?m)^\s*public(?:\s+(?:partial|sealed))*\s+class\s+(\w+)') + if ($m.Success) { return $m.Groups[1].Value } + } + } + return $null +} + foreach ($file in $ChangedFiles) { # Skip non-code files if ($file -notmatch "\.(cs|xaml)$") { continue } @@ -207,7 +241,14 @@ foreach ($file in $ChangedFiles) { # Only Shared.Tests files define actual test classes. # HostApp files are UI pages associated with tests but aren't tests themselves. if ($file -match "TestCases\.Shared\.Tests") { - if ($file -match "[/\\]([^/\\]+)\.cs$") { + # Prefer the class name parsed from the file content over + # the filename basename. maui's test repo often uses a + # category-prefix in the filename that does NOT match the + # actual class name (e.g. CarouselViewUITests.X.cs → class X). + $parsedClass = Get-ClassNameFromFile -RelativePath $file + if ($parsedClass) { + $testName = $parsedClass + } elseif ($file -match "[/\\]([^/\\]+)\.cs$") { $testName = $matches[1] } $filter = $testName @@ -223,7 +264,10 @@ foreach ($file in $ChangedFiles) { } "XamlUnitTest" { - if ($file -match "[/\\]([^/\\]+)\.(cs|xaml)$") { + $parsedClass = Get-ClassNameFromFile -RelativePath $file + if ($parsedClass) { + $testName = $parsedClass + } elseif ($file -match "[/\\]([^/\\]+)\.(cs|xaml)$") { $testName = $matches[1] $testName = $testName -replace '\.(rt|rtsg|rtxc|xaml)$', '' } @@ -232,7 +276,10 @@ foreach ($file in $ChangedFiles) { } "DeviceTest" { - if ($file -match "[/\\]([^/\\]+)\.cs$") { + $parsedClass = Get-ClassNameFromFile -RelativePath $file + if ($parsedClass) { + $testName = $parsedClass + } elseif ($file -match "[/\\]([^/\\]+)\.cs$") { $className = $matches[1] # Strip platform suffix: EditorTests.iOS → EditorTests $className = $className -replace '\.(iOS|Android|Windows|MacCatalyst)$', '' @@ -256,7 +303,10 @@ foreach ($file in $ChangedFiles) { } "UnitTest" { - if ($file -match "[/\\]([^/\\]+)\.cs$") { + $parsedClass = Get-ClassNameFromFile -RelativePath $file + if ($parsedClass) { + $testName = $parsedClass + } elseif ($file -match "[/\\]([^/\\]+)\.cs$") { $testName = $matches[1] } diff --git a/.github/skills/code-review/SKILL.md b/.github/skills/code-review/SKILL.md index 3f0b145ffa04..1a8d1bb0b37b 100644 --- a/.github/skills/code-review/SKILL.md +++ b/.github/skills/code-review/SKILL.md @@ -2,10 +2,11 @@ name: code-review description: >- Deep code review of PR changes for correctness, safety, and MAUI conventions. - Uses independence-first assessment (code before narrative) with 345 lines of - maintainer-sourced review rules. Triggers on: "review code for PR", "code review PR", - "analyze code changes", "check PR code quality". Do NOT use for: summarizing PRs, - describing what changed, general PR questions, running tests, or fixing code. + Uses independence-first assessment (code before narrative) and delegates to the + maui-expert-reviewer agent for per-dimension sub-agent evaluation. Triggers on: + "review code for PR", "code review PR", "analyze code changes", "check PR code quality". + Do NOT use for: summarizing PRs, describing what changed, general PR questions, + running tests, or fixing code. --- # Code Review Skill @@ -17,7 +18,7 @@ Standalone skill that evaluates PR code changes for correctness, safety, perform **Do NOT use for:** "what does PR #XXXXX do?", "summarize PR", "describe the changes", or any informational query — just answer those directly without invoking this skill. > **How this differs from other skills:** -> - **`pr-review`** — End-to-end PR workflow (3 phases: pre-flight with code review, try-fix, report; gate runs separately). Use when you want the full pipeline including test verification and fix attempts. Pre-Flight invokes this skill as a sub-agent for independence-first code analysis. +> - **`pr-review`** — End-to-end PR workflow (4 phases: pre-flight, gate, try-fix, report). Use when you want the full pipeline including test verification and fix attempts. > - **`pr-finalize`** — Verifies PR title/description match implementation + light code review. Use before merging. > - **`code-review`** (this skill) — Deep code-only review with MAUI domain rules. Use when you want a thorough code analysis without running tests or modifying the PR. @@ -71,9 +72,24 @@ Standalone skill that evaluates PR code changes for correctness, safety, perform git log --oneline -10 -- ``` -### Step 2: Load Review Rules +### Step 2: Delegate to Expert Reviewer -Read `.github/skills/code-review/references/review-rules.md`. These rules are distilled from real code reviews by senior MAUI maintainers across 142 high-discussion PRs. +Delegate to the `maui-expert-reviewer` agent (`.github/agents/maui-expert-reviewer.md`) which runs per-dimension sub-agent evaluation. The agent's sole output is `inline-findings.json` — file:line comments in GitHub Review API format. + +**After the agent finishes:** + +- **If `COMMENTS_VIA_FILE=true`** (CI): Done. The pipeline calls `post-inline-review.ps1` to post findings using `GH_COMMENT_TOKEN`. +- **If `COMMENTS_VIA_FILE` is unset** (local): Post inline findings directly: + ```bash + COMMIT_SHA=$(gh pr view $PR_NUMBER --json headRefOid --jq .headRefOid) + gh api repos/dotnet/maui/pulls/$PR_NUMBER/reviews \ + --method POST \ + --input <(jq -n \ + --arg sha "$COMMIT_SHA" \ + --arg body "Expert review — see inline comments." \ + --argjson comments "$(cat CustomAgentLogsTmp/PRState/$PR_NUMBER/PRAgent/inline-findings.json)" \ + '{commit_id: $sha, body: $body, event: "COMMENT", comments: [$comments[] | {path, line, body, side: "RIGHT"}]}') + ``` ### Step 3: Form Independent Assessment @@ -82,7 +98,7 @@ Based ONLY on the code (no PR description), answer: 1. **What does this change do?** Describe the behavioral change in your own words 2. **Why might it be needed?** Infer motivation from the code 3. **Is the approach sound?** Would a simpler alternative work? -4. **What problems do you see?** Run through the review rules AND the MAUI-Specific Review Checklist below +4. **What problems do you see?** Run through the agent's dimension CHECKs for matched dimensions ### Step 4: Read PR Narrative and Reconcile @@ -119,33 +135,6 @@ Then deliver your verdict: --- -## MAUI-Specific Review Rules - -Apply the rules in `references/review-rules.md` to each changed file. The rules are distilled from real code reviews across 142 high-discussion PRs and cover 20 categories: - -**Platform & Lifecycle:** Handler lifecycle, platform-specific code, Android, iOS/macCatalyst, Windows -**Architecture:** Memory management, threading, safe area, layout, navigation, CollectionView -**Code Quality:** Error handling, null safety, performance, XAML & bindings, API design -**Ecosystem:** Testing, build & MSBuild, image handling, gestures, accessibility - -The rules file also includes a **"What NOT to Flag"** section — respect it to avoid noise. - ---- - -## Multi-Model Review (Optional) - -When the environment supports multiple models, run the review in parallel for diverse perspectives. Different model families catch different classes of issues. - -**How:** -1. Select 2-3 models from different families (e.g., Claude + GPT + Gemini) -2. Launch sub-agents in parallel, each running the full 6-step workflow above -3. Synthesize: deduplicate findings, elevate issues flagged by multiple models -4. Present unified review noting which findings had multi-model agreement - -**Timeout:** If a sub-agent hasn't completed after 5 minutes, proceed with available results. - ---- - ## Review Output Format **Constraints (from Android team's approach):** @@ -194,23 +183,30 @@ When the environment supports multiple models, run the review in parallel for di 3. **Never approve what you can't verify.** If the fix touches platform code you can't fully reason about, say so explicitly and use `NEEDS_DISCUSSION`. 4. **LGTM means no ❌ Errors.** You can LGTM with 💡 Suggestions. You can LGTM with ⚠️ Warnings only if you've explained why they're acceptable. 5. **🚨 NEVER use `--approve` or `--request-changes` on GitHub.** Only post comments. Approval is a human decision. -6. **Output to terminal only by default.** Do not post review comments to GitHub (`gh pr review --comment`) unless explicitly asked by the user or orchestrated by another agent. This matches `pr-finalize` policy. +6. **Write findings to disk, do not post directly.** The agent does not have the GitHub comment token. Write findings to `CustomAgentLogsTmp/PRState/{PR}/PRAgent/` — the CI pipeline or posting scripts handle GitHub interaction. --- ## Posting the Review -After completing your review, suggest using the `Post-CodeReview.ps1` script to format and post the comment. **Do NOT post automatically** - always let the user decide when to post. +The agent writes findings to disk. Posting is done separately by `Review-PR.ps1`: +**Inline review comments** (preferred — findings at exact file:line): ```bash -# Save your review to a file, then suggest: -pwsh .github/scripts/Post-CodeReview.ps1 -PRNumber -ReviewFile /tmp/review.md -DryRun +# Preview first: +pwsh .github/scripts/post-inline-review.ps1 -PRNumber -DryRun + +# Post when ready: +pwsh .github/scripts/post-inline-review.ps1 -PRNumber +``` -# User can then post when ready: -pwsh .github/scripts/Post-CodeReview.ps1 -PRNumber -ReviewFile /tmp/review.md +**Wall-of-text summary** (phase content assembled into a single PR comment): +```bash +# Called by Review-PR.ps1 automatically: +pwsh .github/scripts/post-ai-summary-comment.ps1 ``` -The script wraps the review in a collapsible `
` section, adds PR metadata (commit SHA, title), and auto-detects the verdict for a colored status dot (🟢 Approved, 🟡 Changes Suggested, 🟠 Discussion Needed). +In CI (`eng/pipelines/ci-copilot.yml`), `Review-PR.ps1` calls both `post-inline-review.ps1` (for inline findings) and `post-ai-summary-comment.ps1` (for the wall-of-text from `{phase}/content.md` files), using `GH_COMMENT_TOKEN`. --- diff --git a/.github/skills/code-review/references/review-rules.md b/.github/skills/code-review/references/review-rules.md deleted file mode 100644 index 38831b6d740d..000000000000 --- a/.github/skills/code-review/references/review-rules.md +++ /dev/null @@ -1,345 +0,0 @@ -# .NET MAUI Review Rules - -Distilled from code reviews by senior maintainers of dotnet/maui. -Covers 142 high-discussion PRs with 2,883 review comments. - ---- - -## 1. Handler Lifecycle & Patterns - -Handlers bridge the cross-platform virtual view to the native platform view. -Lifecycle mistakes cause leaks, crashes on reconnect, and orphaned event subscriptions. - -| Check | What to look for | -|-------|-----------------| -| **ConnectHandler / DisconnectHandler symmetry** | Every listener, event handler, or callback registered in `ConnectHandler` must be unregistered in `DisconnectHandler`. Asymmetry is the #1 source of handler leaks. (PR #31022, PR #32278) | -| **Don't null handler references eagerly in Disconnect** | The view might be removed and re-added to the window (e.g., Shell tab switching). Setting `_handler = null` in `DisconnectHandler` breaks reconnection. Prefer clearing subscriptions while keeping the weak reference alive. (PR #7886) | -| **Assign per-view state in AttachedToWindow / DetachedFromWindow** | For Android, register layout listeners or inset listeners in `AttachedToWindow` and unregister in `DetachedFromWindow` rather than in the constructor. This avoids leaks when views are recycled. (PR #31022, PR #32278) | -| **Mapper methods must be idempotent** | Mapper callbacks can be called at any time, not just initial setup. They must fully initialize state from scratch — don't assume defaults or rely on prior calls. (PR #15512) | -| **Use `ModifyMapping` for Controls-layer overrides** | When adding mapper properties at the Controls level that override Core behavior, use `Mapper.ModifyMapping` so user-registered mappings aren't silently replaced. (PR #15512) | -| **Commands vs Mapper properties** | Commands (`CommandMapper`) are for requests from cross-platform to platform code (`ScrollTo`, `Remove`). Mapper properties associate with `BindableProperty` values. Don't mix the two patterns. (PR #15512) | -| **Base class calls ordering** | `ConnectHandler` should call `base.ConnectHandler()` before custom setup. `DisconnectHandler` should clean up before calling `base.DisconnectHandler()`. Reversed ordering can access disposed resources. (PR #32278) | -| **Centralize listener instances via static registry** | For listeners that are per-CoordinatorLayout or per-DrawerLayout (e.g., inset listeners), prefer a static registry method over instantiating a new listener object per call. Reduces allocations and centralizes lifecycle. (PR #32278) | - ---- - -## 2. Memory Management & Leak Prevention - -iOS and Android have fundamentally different GC behaviors. iOS's reference-counting -GC is especially sensitive to cycles. Android's Java/C# bridge creates hidden roots. - -| Check | What to look for | -|-------|-----------------| -| **Store handler references as `WeakReference`** | Platform views that communicate back to their handler must store `WeakReference` — not a strong reference. A strong handler ↔ platform view cycle prevents collection, especially on iOS. (PR #7886, PR #20124) | -| **Prefer delegates/Funcs over handler references** | Layout code uses `Func<>` callbacks to communicate without coupling to handler instances. Adopt this pattern: the platform view stores a `Func<>` rather than an `IViewHandler` reference. (PR #7886) | -| **Prefer static callbacks on iOS** | iOS tends to do better cleaning things up when the callback target is a static method. Move gesture recognizer callbacks and event handlers into static methods where feasible, passing state through the sender/tag. (PR #7886) | -| **Unsubscribe and dispose Android listeners** | Android listeners that extend `Java.Lang.Object` should be unsubscribed (`view.SetOnXxxListener(null)`) in `DisconnectHandler` to remove Java's reference. Also call `_listener?.Dispose(); _listener = null;` to release the Java peer. The unsubscribe is often more important than the Dispose — if the handler is GC'd, the listener will be collected too, but Java's reference to the listener prevents that from happening. (PR #31022) | -| **Closures capturing UIKit views are leaks** | Lambdas that close over `UIView`, `UIScrollView`, or any `NSObject` subclass create hidden strong references that the iOS GC cannot break. Extract the view access into a local, use a weak reference capture, or mark the lambda `static` to force no captured variables at compile time. (PR #13499) | -| **NSString and other IDisposable iOS types** | Static `NSString` constants (e.g., notification names) should be declared once as `static readonly` fields, not allocated on every use. Repeated allocation of undisposed `NSString` increases memory pressure. (PR #13499) | -| **CollectionView attached property memory impact** | Data stored on `BindableObject` via attached properties persists for the CollectionView's lifetime. For per-item or per-layout data, store it on the handler instance instead. CollectionView memory is critical. (PR #29496) | -| **Add memory leak device tests for new subscriptions** | When adding new event subscriptions or handler references, consider adding a leak-detection device test that verifies the handler/view can be collected after disconnect. (PR #20124, PR #31022) | - ---- - -## 3. Safe Area (iOS/macCatalyst) - -Safe area is the most frequently regressed subsystem. macOS CI runs on macOS 14/15 -(~28px title bar inset), but local dev may use macOS 26+ (~0px). Fixes must pass CI. - -| Check | What to look for | -|-------|-----------------| -| **Opt-in model: only `ISafeAreaView` / `ISafeAreaView2` views** | Only views implementing `ISafeAreaView` should receive safe area adjustments. Non-safe-area views must return empty padding, not device insets. (PR #30337) | -| **No double-padding across ancestor chain** | Before applying safe area adjustments, walk ancestors checking if any already handle the same edges. Edge-aware: parent handling `Top` does not block child handling `Bottom`. (PR #30337, PR #15512) | -| **Raw vs adjusted inset comparison** | `_safeArea` is filtered by `GetSafeAreaForEdge` (zeros edges per `SafeAreaRegions`); raw `UIView.SafeAreaInsets` includes all edges. Never compare them — compare raw-to-raw or adjusted-to-adjusted. (PR #30337) | -| **Never gate view callbacks on window-level insets** | Comparing `Window.SafeAreaInsets` to filter per-view `SafeAreaInsetsDidChange` callbacks blocks legitimate updates. On macCatalyst with custom TitleBar, the view's insets change without the window's changing, causing a 28px shift on CI. (PR #30337) | -| **Use constants for magic strings** | Property names like `"SafeAreaInsets"` used in mapper lookups must be constants (e.g., `PlatformConfiguration.iOSSpecific.Page.SafeAreaInsetsProperty.PropertyName`). Bare strings will break silently if renamed. (PR #15512) | -| **New safe area types belong in `src/Core`** | Types like `SafeAreaRegions` must be in `Core.csproj` so that `ISafeAreaView2` can reference them. Don't add core interface dependencies to `Controls.csproj`. (PR #30337) | -| **Don't use ISafeAreaView2 if ISafeAreaView can be extended** | Before creating a versioned interface like `ISafeAreaView2`, check if the existing interface can be extended with default interface methods or deprecated members. Prefer extending over versioning. (PR #30337 — StephaneDelcroix) | - ---- - -## 4. Layout & Measure - -Layout is the hot path. Mistakes cause infinite measure loops, incorrect sizing, -and subtle clipping issues that only manifest on specific device/OS combinations. - -| Check | What to look for | -|-------|-----------------| -| **Propagate changes through virtual view, not INCC** | Collection changes (e.g., map elements, picker items) should propagate via `Handler.UpdateValue(PropertyName)` at the Controls level, not via `INotifyCollectionChanged` from the platform view. INCC creates tight coupling. (PR #7886) | -| **Guard against infinite ContentSize oscillation** | On iOS, `MauiScrollView` can enter infinite loops when content with very large `ContentSize` triggers layout → resize → layout cycles. Add a guard (e.g., `EqualsAtPixelLevel` comparison) to break sub-pixel oscillation caused by animation noise. (PR #26629, PR #30337) | -| **Compare sizes at pixel resolution** | Safe area and content size comparisons must account for device-pixel rounding. Use `EqualsAtPixelLevel` (threshold ~0.0000001pt) to prevent oscillation during `TranslateToAsync` animations. (PR #30337) | -| **Don't apply padding in aspect ratio calculations** | When computing image aspect ratios on iOS, include padding for sizing but not for the aspect ratio computation itself. Padding should be added after the aspect ratio is applied. (PR #26629) | -| **Matrix test nesting for visibility propagation** | When testing `IsVisible` propagation through nested containers, test the full matrix: 2-level and 3-level nesting, set/unset sequences. A single level test misses propagation bugs. (PR #20154 — mattleibow) | - ---- - -## 5. Platform-Specific Code - -| Check | What to look for | -|-------|-----------------| -| **File extensions determine compilation targets** | `.android.cs` → Android only. `.ios.cs` → iOS AND MacCatalyst. `.maccatalyst.cs` → MacCatalyst only. `.windows.cs` → Windows only. Both `.ios.cs` and `.maccatalyst.cs` compile for MacCatalyst — check for duplicate definitions. (PR #24396) | -| **Use type aliases for namespace collisions** | `View`, `Color`, `Context` exist in both MAUI and Android/iOS/Windows namespaces. Use `using AView = Android.Views.View;`, `using NativeScrollView = Microsoft.UI.Xaml.Controls.ScrollViewer;`, etc. Prevents subtle misresolution bugs. (PR #3351 — mattleibow) | -| **Platform views must live in `Microsoft.Maui.Platform` namespace** | Custom native view wrappers (e.g., `MauiHybridWebView`, `MauiHybridWebViewClient`) must be in `Platform//` with `namespace Microsoft.Maui.Platform`. Don't put them in handler directories. (PR #22880 — mattleibow) | -| **Don't change handler generic type parameters** | Changing the generic type on a handler (e.g., `ViewHandler` → `ViewHandler`) is a binary breaking API change. Leave existing generics as-is. (PR #13499 — PureWeen) | -| **Align cross-platform behavior** | When fixing behavior on one platform, verify the behavior is consistent on others. A flyout state fix on iOS should match Windows behavior. Reviewers will ask: "What does Windows/Android do here?" (PR #26701 — jsuarezruiz) | -| **Reuse platform APIs via extension methods** | If a platform already has a method (e.g., `FileSystemPlatformOpenAppPackageFile`), use it. Don't duplicate file-opening logic in handler-specific code. (PR #22880 — mattleibow) | - ---- - -## 6. Android Platform - -| Check | What to look for | -|-------|-----------------| -| **Store `Context` in a local before repeated use** | Accessing Android's `Context` property calls into Java each time (JNI marshaling). Store it in a local: `var context = Context;` then use the local. Same applies to any property that crosses the Java/C# bridge. (PR #26789 — jonathanpeppers) | -| **Android resource files need correct build action** | Files used in Android tests must be declared with the correct build action (e.g., `AndroidResource`, `EmbeddedResource`). A file at `/red.png` with no build action causes `FileNotFoundException` on Android only. (PR #14109 — jonathanpeppers) | -| **Use `PlatformLogger` for Android native code** | In Java code under `src/Core/AndroidNative/`, use `PlatformLogger` for logging — not `android.util.Log` directly. This ensures consistent log formatting. (PR #29780 — jonathanpeppers) | -| **Use `FragmentActivity` carefully with Glide** | When resolving Glide request managers, check Glide's own source for the correct `Activity` lookup pattern. Don't add unnecessary `FragmentActivity` checks that diverge from Glide's implementation. (PR #29780 — jonathanpeppers) | -| **Tests in Java won't run without CI changes** | New Java test projects require AzDO/yaml/CI pipeline updates. If CI changes aren't included, the tests won't execute. Write device tests in C# instead. (PR #29780 — jonathanpeppers) | - ---- - -## 7. iOS/macCatalyst Platform - -| Check | What to look for | -|-------|-----------------| -| **iOS has trouble collecting objects with handler references** | When an iOS platform view holds a reference to its handler, the reference-counting GC often cannot break the cycle. Use delegates, `Func<>`, or `WeakReference` patterns. See `DatePickerHandler.ios.cs` (`DatePickerDelegate`) for the recommended proxy pattern. (PR #7886 — PureWeen) | -| **Subscribe/unsubscribe in `MovedToWindow`** | For iOS callbacks that need handler access, subscribe when the view moves to a window and unsubscribe when removed. This is more reliable than constructor/dispose for iOS lifecycle. (PR #7886 — PureWeen) | -| **Store notification `UserInfo` before repeated access** | Accessing `notification.UserInfo` multiple times with null-conditional (`?.`) is wasteful and obscures null checks. Store `var userInfo = notification.UserInfo;`, null-check once, then use the methods. (PR #13499 — mandel-macaque) | -| **Check `Handle == IntPtr.Zero` for disposed native objects** | A `UICollectionView` or other native object may be disposed but not null. Check `collectionView?.Handle == IntPtr.Zero` as an additional guard against accessing disposed objects. (PR #29397 — jsuarezruiz) | -| **Wrap CollectionView layout callbacks in try-catch** | Layout factory callbacks can fire after disposal. Wrap in `catch (Exception ex) when (ex is ObjectDisposedException or InvalidOperationException)` to prevent crashes. (PR #29397 — jsuarezruiz) | -| **`UIImage.FromImage` creates a copy** | Calling `UIImage.FromImage` allocates a new instance. If you only need to transform the existing image, modify in place when possible to avoid double memory usage. (PR #26016 — jsuarezruiz) | -| **Use `IUITextInput` interface for cursor/text range** | When accessing `SelectedTextRange` or similar text input properties across `UITextField`/`UITextView`, use the `IUITextInput` interface to avoid duplicating code for each concrete type. (PR #13499 — mandel-macaque) | -| **macCatalyst defaults `UseSafeArea` to `true`** | Unlike iOS where `UseSafeArea` defaults to `false`, macCatalyst defaults to `true`. Code that assumes `false` across Apple platforms will misbehave on macCatalyst. (PR #30337) | - ---- - -## 8. Windows Platform - -| Check | What to look for | -|-------|-----------------| -| **Appium on WinUI can't retrieve non-accessible elements** | `BoxView` and other elements without text aren't visible to the WinUI accessibility tree. Use `Label` or elements with text content for Appium-based UI test assertions on Windows. (PR #19371 — PureWeen) | -| **Check null/empty collections before `.FirstOrDefault()`** | On Windows, calling `.FirstOrDefault().ToPlatform()` on an empty (but non-null) `Accelerators` collection will throw. Add an empty-collection guard. (PR #14740 — mattleibow) | -| **WebView2 assembly identity differs between WinUI and WPF** | The WebView2 types have different assembly identities across WinUI, WPF, and WinForms. You cannot directly share WebView2 helper code between these targets. (PR #654 — Eilon) | -| **Prefix new MSBuild properties with `Maui`** | Any new MSBuild property (e.g., `EnableXamlLoading`) must be prefixed with `Maui` (e.g., `MauiEnableXamlLoading`) to avoid collisions with WindowsAppSdk or other framework properties. (PR #19310 — jonathanpeppers) | -| **Apply theme per window, not to all windows** | In `OnWindowHandlerChanged`, don't call `ApplyThemeToAllWindows()` — it iterates all windows redundantly (N+N-1+...+1 total applications for N windows). Apply theme only to the specific window from the sender. (PR #31714 — jsuarezruiz) | -| **Track applied state to avoid redundant work** | Theme and style application should track whether it's already been applied per window (e.g., using a `Dictionary`). Re-applying on every handler change without checking if the theme actually changed is a performance hit. (PR #31714 — jsuarezruiz) | - ---- - -## 9. Navigation & Shell - -| Check | What to look for | -|-------|-----------------| -| **Shell re-adds views on tab switch** | Shell removes and re-adds platform views when users switch tabs or flyouts. Code that nullifies state in `DisconnectHandler` or `RemovedFromSuperview` will break on re-navigation. (PR #7886 — PureWeen) | -| **Test flyout state after window resize AND rotation** | Flyout visibility bugs often differ between maximize/restore and rotate-to-landscape/rotate-back scenarios. Create separate tests for each rather than combining into a single test method. (PR #26701 — PureWeen) | -| **Split unrelated behaviors into separate tests** | When a test covers two different behaviors (e.g., flyout-after-maximize AND flyout-after-rotation), split into separate test methods. Combined tests obscure which scenario fails. (PR #26701 — PureWeen) | -| **Security: validate WebView URL mapping** | When loading local HTML content in `WebView`, the local file mapping hostname should be random or scoped to prevent cross-origin file access. An app calling `LoadHtml` with `baseUrl: null` could inadvertently expose local files. (PR #7672 — Eilon) | -| **More tab behavior is platform-specific** | iOS's "More" tab for overflow Shell items may not have a standard Apple-defined behavior. Verify against Apple HIG before assuming push navigation from the More tab is correct. (PR #26292 — mattleibow) | - ---- - -## 10. CollectionView - -Two handler implementations exist. Items/ is the only implementation for Android -and Windows. Items2/ is the current handler for iOS/MacCatalyst (Items/ iOS is deprecated). - -| Check | What to look for | -|-------|-----------------| -| **Verify correct handler directory for platform** | Android/Windows changes go in `Handlers/Items/`. iOS/MacCatalyst changes go in `Handlers/Items2/`. Items2/ has NO Android or Windows code. Modifying the wrong directory is a no-op on the target platform. (PR #29397, PR #31336) | -| **Don't copy already-marshaled ObjC arrays** | iOS binding APIs like `indexPathsForVisibleItems` already copy the ObjC array to managed code via `CFArray.ArrayFromHandle`. Creating a second copy (e.g., `.ToArray()`) is wasteful. (PR #31336 — jonathanpeppers) | -| **MeasureFirstItem cache must distinguish item types** | When `MeasureFirstItem` is used with grouped CollectionView, the GroupHeader size gets cached and applied to all items if the cache key doesn't distinguish between headers and data items. Causes clipping. (PR #27847 — PureWeen) | -| **CollectionView inside ScrollView causes infinite loops** | Placing a CollectionView inside a ScrollView (which users shouldn't do, but do) can cause infinite layout loops on iOS due to unbounded `ContentSize`. Add guards. (PR #26629 — rmarinho) | -| **Include gallery samples alongside tests** | When fixing EmptyView, DataTemplateSelector, or other complex CollectionView features, add samples to `Controls.Sample/Pages/Controls/CollectionViewGalleries/` for manual validation alongside automated tests. (PR #25418 — jsuarezruiz) | -| **Validate item class names are unique** | ViewModels inside test files (e.g., `CollectionViewViewModel`) must be namespaced uniquely (e.g., `Issue29130ViewModel`). Duplicate class names across issues cause build errors. (PR #29496 — jsuarezruiz) | - ---- - -## 11. Threading & Async - -| Check | What to look for | -|-------|-----------------| -| **Use `Interlocked.Increment` for counters accessed from UI thread** | Even counters "most likely" called on the UI thread should use `Interlocked` for safety. A debounce counter without thread safety can miss update requests. (PR #13499 — PureWeen) | -| **Don't reset debounce counters — roll them over** | Resetting a debounce count to 0 can cause race conditions where an update request is missed. Roll the counter over at a high threshold (e.g., 100) instead. (PR #13499 — PureWeen) | -| **Check if already on main thread before dispatching** | Before calling `MainThread.BeginInvokeOnMainThread` or `Dispatcher.Dispatch`, check if you're already on the main thread. Unnecessary dispatch adds latency and can reorder operations. (PR #26153 — PureWeen) | -| **`Task.Delay` in tests needs justification** | A `Task.Delay(100)` in a device test is a flaky test waiting to happen. Reviewers will ask: "How do we know 100ms is enough?" Prefer `WaitForMainThread()` or similar deterministic helpers. (PR #14619 — jonathanpeppers) | -| **Create helper methods for common async test patterns** | Repeated `await InvokeOnMainThreadAsync(() => { })` should be extracted into a `WaitForMainThread()` helper. Duplicate async boilerplate is error-prone. (PR #14619 — jonathanpeppers) | -| **Check `DispatcherQueue` for null before posting** | On Windows, `DispatcherQueue` can be null if the Window is disposed. Guard dispatch calls with a null check. (PR #31714 — jsuarezruiz) | - ---- - -## 12. XAML & Bindings - -| Check | What to look for | -|-------|-----------------| -| **Compiled bindings require explicit `x:DataType`** | Every `{Binding}` with an explicit `Source` must have an explicit `x:DataType` on the binding or a parent element. Missing `x:DataType` prevents source generation and causes runtime reflection fallback. (PR #32444 — simonrozsival) | -| **Set `x:DataType` on root element for page-level BindingContext** | When a page sets `BindingContext` in code-behind, the root `ContentPage` element needs `x:DataType="local:MyViewModel"` to enable compiled bindings for all child elements. (PR #32444 — simonrozsival) | -| **Don't subscribe on every BindingContext change** | In `TemplatedCell` and similar reusable views, subscribing to events on BindingContext change without checking for diff will accumulate multiple subscriptions. Only subscribe if the BindingContext actually changed. (PR #14619 — rmarinho) | -| **Use `SetValue(BP, ...)` when BindableProperty exists** | When a source generator heuristic determines a BindableProperty will be generated, the generated code must use `.SetValue(BP, ...)` instead of calling the property setter directly. (PR #32597 — simonrozsival) | -| **Remove dead code from source generation** | When source-gen skips properties via `SkipProperties`, the `CreateValuesVisitor` should also skip `new` instantiations for those properties. Leftover dead code confuses reviewers and wastes binary size. (PR #32474 — simonrozsival) | -| **Future-proof message types with records** | When adding a new cross-platform messaging API (e.g., `SendRawMessage`), pass a `record` type instead of a bare `string`. This allows adding fields later without breaking the API. (PR #22880 — mattleibow) | -| **Markup extension recognition should be semantic** | Don't just check suffix (`FooExtension`); query the compilation for types implementing `IMarkupExtension`. Also support prefixed extensions (`{local:MyExtension}`). (PR #33693 — simonrozsival) | -| **Auto-escape XML-unfriendly characters in expressions** | Users should not need to type `>` in XAML C# expressions. Use `` or automatic escaping for `<`, `>`, `&&`, `||` in expression contexts. (PR #33693 — simonrozsival) | - ---- - -## 13. Testing - -| Check | What to look for | -|-------|-----------------| -| **UI tests must run on all applicable platforms** | Do not restrict tests to a single platform unless there is a specific technical limitation. Tests should always cover iOS, Android, and Windows unless the fix is platform-specific. (PR #32064 — PureWeen) | -| **Snapshot baselines must be updated across all platforms** | Changing background color, font, or layout requires updating snapshot baselines for Android, iOS, MacCatalyst, and Windows. Stale baselines cause false failures. (PR #25129, PR #27399 — jsuarezruiz) | -| **Screenshot size must match capture method** | If the screenshot capture mechanism changes (e.g., different DPI or crop), all baselines need regeneration. A size mismatch (e.g., 1920×1080 vs 789×563) means the capture changed, not the rendering. (PR #25129 — jsuarezruiz) | -| **Use `VerifyScreenshot(retryTimeout:)` instead of `Task.Delay`** | `VerifyScreenshot` has built-in retry logic. Adding `Task.Delay` before it is redundant. Use `retryTimeout: TimeSpan.FromSeconds(2)` for animations. (PR #32064) | -| **Make test labels visible even if content is clipped** | When testing clipping or canvas rendering, position a label at the edge of the drawn content so screenshots prove content was actually drawn, not just that the clip removed everything. (PR #28353 — mattleibow) | -| **Memory consumption tests on Android** | Use Appium's `GetMemoryInfo()` helper to validate memory consumption in tests. Set a threshold and assert memory stays below it to detect regressions. (PR #26789 — jsuarezruiz) | -| **Tests that verify two behaviors need two methods** | A test called `ShouldFlyoutBeVisibleAfterMaximizingWindow` that also tests rotation is actually two tests. Split them so failures pinpoint the exact regression. (PR #26701 — PureWeen) | -| **Test types should match test project infrastructure** | Source generator tests belong in `SourceGen.UnitTests.csproj`, not `Xaml.UnitTests.csproj`. Tests that don't need `[Values] XamlInflator` shouldn't use it — running 3 identical iterations wastes CI time. (PR #32474 — simonrozsival) | - ---- - -## 14. Performance - -| Check | What to look for | -|-------|-----------------| -| **Cache JNI property access in locals** | Android properties like `Context`, `Resources`, `ContentDescription` cross the Java/C# bridge on every access. Store in a local variable when used more than once in a method. (PR #26789 — jonathanpeppers) | -| **Avoid closures that increase GC pressure** | Closures capturing UIKit objects create extra GC-tracked objects with references to captured elements. Even if technically correct, this increases memory pressure. Prefer explicit parameter passing or static methods. (PR #13499 — mandel-macaque) | -| **`ValueTuple.GetHashCode()` may allocate** | `ValueTuple.GetHashCode()` for large tuples can allocate. For hash-code–critical types like `SetterSpecificity`, implement `GetHashCode()` explicitly to avoid boxing and allocation. (PR #13818 — jonathanpeppers) | -| **Prefer `IReadOnlyList` on public APIs** | Public methods should return `IReadOnlyList` or `IReadOnlyCollection` instead of mutable `List`. This communicates intent and prevents callers from corrupting internal state. (PR #14740 — mattleibow) | -| **Avoid double-copy of managed arrays from ObjC** | iOS binding APIs already marshal ObjC arrays into C# collections. Calling `.ToArray()` or `.ToList()` on the result creates a redundant copy. (PR #31336 — jonathanpeppers) | -| **Use `StringBuilder` or `List` for code generation** | In source generators, building output strings with repeated `+=` is O(n²). Use `StringBuilder`, `List` with `string.Join`, or append patterns that avoid intermediate allocations. (PR #32420 — simonrozsival) | -| **Allocate early, check cheap conditions first** | In validation chains, test simple boolean flags and null checks before allocating strings or doing I/O. This is especially important in mapper callbacks which run frequently. (PR #28077 — jsuarezruiz) | -| **Don't remove caches without benchmarks** | If a cache (like `SetterSpecificityList`) was added with measured performance wins, removing or replacing it requires proving the alternative provides equivalent or better performance. Use `dotnet-trace` and `speedscope.app`. (PR #17756 — jonathanpeppers) | -| **Flatten nested LINQ into single-level iteration** | Nested `foreach` + `SelectMany` over chained mappers can be flattened: `foreach (var key in Chained.Reverse().SelectMany(c => c.GetKeys()))`. But always benchmark to verify improvement. (PR #28077 — jsuarezruiz) | - ---- - -## 15. Error Handling & Null Safety - -| Check | What to look for | -|-------|-----------------| -| **Check if stream is seekable before copying** | When processing image or data streams, check `stream.CanSeek` first. If seekable, use the original stream directly instead of copying to a `MemoryStream`. (PR #29769 — jsuarezruiz) | -| **Pattern match instead of cast + null check** | Prefer `if (localCursor is CGRect rect)` over `as` + null check. Pattern matching is safer with value types (where `as` doesn't compile) and more readable. (PR #13499 — tj-devel709) | -| **Consistent null initialization** | Don't initialize nullable reference variables to `null` in some places but not others. Be consistent — either always set `= null` or never set it (let the default apply). (PR #13499 — mandel-macaque) | -| **Use `?.` chains judiciously** | Multiple `?.` on the same expression (e.g., `notification.UserInfo?.ObjectForKey(...)?.ToString()`) is harder to debug. Store intermediates and null-check explicitly when the chain is more than 2 deep. (PR #13499 — mandel-macaque) | -| **Fallback when `MauiContext` is null** | If `Window.MauiContext` is null, fall back to `Application.Current.FindMauiContext()` rather than letting a `NullReferenceException` propagate. (PR #24808 — jsuarezruiz) | -| **Initialize WebView cookies in `CoreWebView2Initialized`** | Cookie preloading that runs before `CoreWebView2` is initialized hits null references. Wire initialization into the `CoreWebView2Initialized` event. (PR #24846 — PureWeen) | -| **Try-catch for fire-and-forget platform calls** | Platform calls that can fail but whose failures are non-critical should be wrapped in `try/catch` or use `FireAndForget`. Unhandled exceptions in these paths crash the app. (PR #22880 — PureWeen) | -| **Guard against empty collections in chained calls** | `collection?.FirstOrDefault().ToPlatform()` throws if the collection is empty (not null). Check `.Any()` or use null-conditional on the result of `FirstOrDefault()`. (PR #14740 — mattleibow) | - ---- - -## 16. API Design & Public API - -| Check | What to look for | -|-------|-----------------| -| **Adding to an interface is a breaking change** | Adding members to a public interface (e.g., `IMenuElement`) is a binary breaking change. Use default interface methods (verify platform support), create a new interface (`IMenuElement2`), or add an extension method. (PR #14740 — PureWeen) | -| **Never modify `PublicAPI.Shipped.txt`** | To remove a shipped API, copy the line to `PublicAPI.Unshipped.txt` prefixed with `*REMOVED*`. Never edit the Shipped file directly. (PR #14740 — mattleibow) | -| **Don't expose setters that do nothing** | If a property setter is not wired to any handler or has no observable effect, remove it. Dead setters confuse users and accumulate API surface that can't be removed later. (PR #14740 — PureWeen) | -| **Obsolete with proper message format** | Obsolete attributes need a period at the end of the message. iOS Cecil tests enforce this convention. (PR #13499 — mandel-macaque) | -| **Public `MauiAppBuilder` extension methods require careful review** | Once added to the builder pattern, extension methods cannot be removed. Establish a process for evaluating what belongs on the builder vs what library authors should register themselves. (PR #2137 — mattleibow) | -| **Avoid breaking Xamarin.Forms migration** | When replacing types (e.g., `Position` → `Location`), consider keeping a compatibility class that inherits from the new type. This eases porting from Xamarin.Forms. (PR #7886 — jsuarezruiz) | -| **Use named constants instead of magic numbers** | Bit-shift offsets, specificity values, and layout thresholds should be `const int` with descriptive names. `new SetterSpecificity(100, 0, 0, 0)` is opaque; `SetterSpecificity.Implicit` communicates intent. (PR #13818 — jonathanpeppers) | - ---- - -## 17. Image Handling - -| Check | What to look for | -|-------|-----------------| -| **Image source services must return native image representations** | `IImageSourceService.GetDrawableAsync` should return a result that represents the actual image data, not just a status. This enables usage without a view (e.g., notification icons). (PR #2360 — mattleibow) | -| **Verify Glide callback thread assumptions** | Glide callbacks like `onResourceReady` are assumed to be on the main thread because they call `view.setImageDrawable`. But this isn't documented — verify by checking Glide's source. (PR #14109 — jonathanpeppers) | -| **Clean up bitmaps on overlay add/remove cycles** | If an overlay is removed and re-added, resources loaded during the first add must be either cached or reloadable. Disposal without a reload path causes blank overlays. (PR #3351 — mattleibow) | -| **Inner vs outer corner radius for clipping** | When using a `RoundRectangle` for clipping (e.g., inside a `Border`), the corner radius for the inner clip is different from the outer border radius. Use the inner value. Clipping with the outer value leaves visible gaps. (PR #10964 — jsuarezruiz) | - ---- - -## 18. Gestures - -| Check | What to look for | -|-------|-----------------| -| **Use `Tap` over `Click` for mobile platforms** | In UI tests, `Tap` is more flexible and mobile-appropriate. `Click` may not be converted to `Tap` on all platforms, causing test failures on Android/iOS while passing on Windows. (PR #19371 — PureWeen) | -| **Ensure gesture tests verify their precondition** | A test that verifies "GetPosition returns correct coordinates" must confirm the element was actually tapped. If the element isn't tappable (e.g., iOS BoxView issue), the test passes trivially. Use a verifiable side effect. (PR #19371 — PureWeen) | -| **Span tap region calculation across multiple lines** | The `CGRect` region for each `Span` in a `FormattedString` is incorrectly calculated when text wraps to multiple lines (inherited from Xamarin.Forms). Verify tap targets with multi-line text. (PR #15544 — jsuarezruiz) | -| **EventArgs naming convention** | Custom event args should follow `{Event}EventArgs : EventArgs` naming. E.g., if the event is `Touch`, the args class should be `TouchEventArgs`, not `DiagnosticsTouchArgs`. (PR #3351 — mattleibow) | - ---- - -## 19. Build & MSBuild - -| Check | What to look for | -|-------|-----------------| -| **Use `dotnet-public` feed to avoid dependency confusion** | NuGet sources must use the `dotnet-public` feed. Adding arbitrary third-party feeds creates a dependency confusion attack surface. New package sources require approval. (PR #5020 — jonathanpeppers) | -| **Build tasks can't depend on optional packages** | `Controls.Build.Tasks.csproj` cannot reference optional NuGet packages like Maps. Build tasks must only depend on core assemblies that are always present. (PR #7886 — mattleibow) | -| **Feature flag properties belong in `src/Core`** | Feature flags (e.g., `IsXamlLoadingSupported`) should be in `Core.csproj` / `Microsoft.Maui.dll` since all assemblies depend on it. Don't scatter feature flags across Controls or platform-specific assemblies. (PR #19310 — jonathanpeppers) | -| **Follow naming conventions: `Support` suffix → `IsXSupported`** | MSBuild property: `XamlLoadingSupport`. C# property: `IsXamlLoadingSupported`. This matches the runtime feature switch pattern used across .NET. (PR #19310 — simonrozsival) | -| **Document feature switch breakage and alternatives** | For each new feature switch, document: (1) which APIs break when disabled, (2) code examples of what users should do instead. (PR #19310 — jonathanpeppers) | -| **Targets in NuGet vs workload have different import timing** | Moving MSBuild targets from workload to NuGet changes when they're imported relative to package restore. Test the sequence: install VS → new project → NuGet restore → build. (PR #11206 — jonathanpeppers) | -| **Never commit `cgmanifest.json` or `templatestrings.json`** | These are auto-generated during CI. AI-generated PRs frequently include changes to these files. Always reset them before committing. (PR #11206) | - ---- - -## 20. Accessibility - -| Check | What to look for | -|-------|-----------------| -| **Don't disable font scaling globally** | An implicit style that disables font scaling across the app makes it inaccessible to partially-sighted users. "Rather have an ugly app that a partially blind person can use instead of a beautiful one they can't." (PR #1774 — PureWeen) | -| **WinUI Appium requires accessible elements** | Elements without text content (e.g., `BoxView`) are invisible to Appium on WinUI. Use `Label` or set `AutomationProperties.Name` for elements that need to be located in Windows UI tests. (PR #19371 — PureWeen) | -| **Test accessibility properties propagate** | When a control exposes `AutomationProperties`, verify the native accessibility tree reflects them. A broken binding silently removes accessibility. (PR #25011 — jsuarezruiz) | - ---- - -## 21. Regression Prevention (Lessons from Reverts & Candidate Failures) - -Rules distilled from 30 reverted PRs and 50 candidate-branch failures. When a PR touches these areas, apply extra scrutiny. - -| Check | What to look for | -|-------|-----------------| -| **CollectionView changes need broad scenario coverage** | CV is the single highest-regression component (15 candidate failures). Any change to layout, scroll, spacing, cell alignment, Header/Footer, or `KeepLastItemInView` must be tested across all four: empty collection, single item, many items, and with grouping. A fix for one layout scenario routinely breaks another. (CollectionView candidate failures, multiple PRs) | -| **Style/theme changes have cascading effects** | `ApplyToDerivedTypes`, implicit styles, and `AppThemeBinding` interact in non-obvious ways. A fix to one style propagation path often breaks another — this pattern caused two separate reverts for PR #9648 and broke source gen in PR #32728. When touching style resolution or `AppThemeColor`, test: explicit style, implicit style, derived-type style, and dark/light theme switching. | -| **Test the fix scenario AND adjacent scenarios** | Most reverts happen because the fix works for the reported issue but breaks a neighboring case. ToolbarItem image fix (PR #28833, reverted twice) fixed one image mode while breaking others. Entry `SelectionLength` (PR #26213) fixed selection but broke focus. Require authors to enumerate what adjacent behaviors they checked. | -| **Never remove `InternalsVisibleTo` without auditing NuGet consumers** | IVT removal looks like cleanup but silently breaks community packages that depend on internal APIs. At least one revert went all the way back to a release branch because of this. Flag any `InternalsVisibleTo` deletion and ask: "Have you checked whether any published NuGet consumers reference this?" | -| **ToolbarItem/Image changes must be tested across all image source types** | Font images, file images, and tinted images each go through different code paths. PR #28833 (reverted twice) and PR #26048 show this pattern. When modifying `ImageSourceExtensions` or any ToolbarItem rendering code, verify all three modes: `FontImageSource`, `FileImageSource`, and `BitmapImageSource` with tinting. | -| **Entry/Editor focus and selection state is fragile** | `CursorPosition`, `SelectionLength`, keyboard show/hide, and focus order interact tightly on every platform. PR #26213 shows how a `SelectionLength` change broke Entry focus. Flag any handler change that touches these properties and ask whether focus behavior was verified after the change — especially when the keyboard is dismissed and re-shown. | -| **Measurement timing on iOS lags behind property changes** | `UIButton.TitleLabel.Bounds` and `UIView` frame values are not updated synchronously after a property change — the layout pass hasn't run yet. PR #25122 (tj-devel709) shows the correct pattern: measure the title manually instead of reading `.Bounds`. Flag any iOS handler code that reads frame/bounds immediately after setting a property, without deferring to the next layout pass. | -| **Template changes need all-template validation** | A template fix for MAUI app can break Blazor hybrid or multi-project templates. `MapStaticAssets` vs `UseStaticFiles` (candidate failure) shows how a single API swap breaks one template variant silently. Any `src/Templates/` change must be validated against all template IDs: `maui`, `maui-blazor`, `maui-blazor-web`, `mauilib`, `maui-multiproject`. | -| **Candidate-branch PRs must not mix concerns** | PureWeen's explicit rule (PR #33838): candidate fixes should not bundle unrelated flakiness fixes. A PR that mixes "fix the regression" with "also fix this flaky test" makes bisection impossible and obscures what actually fixed the candidate failure. Flag mixed-concern candidate PRs. | -| **Screenshot tests must prove content was drawn, not just that clipping worked** | mattleibow on PR #28353: "give this label a negative margin so that we can see that the image is drawn at all." A clipping test that passes when the view renders nothing is not a useful test. Flag screenshot tests for `GraphicsView`, `Image`, or any drawing surface that don't verify the content region itself — use a visible element inside the clip boundary as a sentinel. | -| **Arithmetic in index/position calculations needs explicit parentheses** | mattleibow on PR #23369: "This line of code is a bit ambiguous for a quick read." Silent operator-precedence bugs in scroll offset, index math, or spacing calculations are hard to spot and have caused gesture/tap regressions. Flag expressions like `a + b * c` or `offset - padding / 2` without explicit parentheses when they appear in position or size computations. | -| **Major dependency upgrades need broad platform validation** | WindowsAppSDK upgrade (PR #32174) was reverted because it broke too many things simultaneously. Flag PRs that bump `WindowsAppSDK`, `Microsoft.Maui.*` NuGet versions, or other platform SDK dependencies, and ask whether CI was green on all platforms (Android, iOS, MacCatalyst, Windows) before merge, not just the changed platform. | -| **ContentPresenter BindingContext propagation breaks explicit TemplateBindings** | Propagating `BindingContext` through `ContentPresenter` overwrites `{TemplateBinding}` values that were set explicitly. This was a reverted PR. Flag any handler or renderer change that sets or propagates `BindingContext` on a `ContentPresenter` or control template root without verifying that `TemplateBinding` expressions still resolve correctly. | - ---- - -## 22. Most Frequently Regressed Components - -Components ranked by regression frequency from 366 analyzed PRs (reverts + candidate fixes + regression fixes): - -| Component | Regressions | Key Risk Areas | -|-----------|-------------|----------------| -| CollectionView | 15 | Layout, scroll position, spacing, cell alignment, Header/Footer | -| Image/Graphics | 15 | Aspect ratio, CornerRadius, Background, DrawString | -| Theme/Style | 8 | AppThemeBinding, implicit styles, ApplyToDerivedTypes | -| CarouselView | 7 | ScrollTo, CurrentItem, ItemSpacing, loop mode | -| Gesture/Tap | 7 | TapGestureRecognizer, SwipeView, outside-tap dismiss | -| Button/Entry | 7 | Dynamic resize, focus/selection, AppThemeBinding colors | -| Toolbar | 5 | Icon color, back button, BarTextColor across modes | -| Shell/TabBar | 4 | TabBarIsVisible, Shell crashes, section rendering | - -Use this table as a triage guide: PRs touching these components warrant a more thorough pass through sections 1–21 above, with particular attention to the adjacent-scenario rule (§21 row 3) and the component-specific rows in this section. - ---- - -## What NOT to Flag - -Do not waste reviewer time on these: - -| Category | Why | -|----------|-----| -| **Style/formatting** | CI enforces via `dotnet format`. | -| **Missing XML docs on non-public APIs** | Not required by MAUI convention. | -| **Test naming preferences** | Unless names are genuinely misleading. | -| **`var` vs explicit types** | Project allows both; consistency within a file is sufficient. | -| **Micro-optimizations in cold paths** | Readability wins unless profiling proves it's a hot path. | -| **Single-use LINQ vs foreach** | Either is fine; don't bikeshed. | -| **Comment style** | Only flag if a comment is factually wrong or stale. | -| **PR commit count/squash** | That's the author's workflow choice. | diff --git a/.github/skills/code-review/tests/eval.yaml b/.github/skills/code-review/tests/eval.yaml index 8e0d8e981045..f02d9d1ad109 100644 --- a/.github/skills/code-review/tests/eval.yaml +++ b/.github/skills/code-review/tests/eval.yaml @@ -26,7 +26,7 @@ scenarios: value: "Devil's Advocate" rubric: - "The agent provides a plain summary without launching a structured multi-step review workflow" - - "The agent does NOT load review-rules.md or walk through MAUI-specific review checklists" + - "The agent does NOT walk through a multi-step review workflow" timeout: 120 - name: "Independence-first - agent reads diff before description" @@ -64,7 +64,7 @@ scenarios: pattern: "(NEEDS_CHANGES|NEEDS_DISCUSSION)" rubric: - "If the agent finds or confirms a ❌ Error-level issue, the verdict is NEEDS_CHANGES — not LGTM" - - "The agent applies handler lifecycle rules from review-rules.md (ConnectHandler/DisconnectHandler symmetry)" + - "The agent applies handler lifecycle rules from the expert reviewer dimensions (ConnectHandler/DisconnectHandler symmetry)" - "The agent cites specific file and line references for the concern" timeout: 300 diff --git a/.github/skills/pr-review/SKILL.md b/.github/skills/pr-review/SKILL.md index eab358b1d112..51baca74c8f3 100644 --- a/.github/skills/pr-review/SKILL.md +++ b/.github/skills/pr-review/SKILL.md @@ -244,10 +244,14 @@ CustomAgentLogsTmp/PRState/{PRNumber}/PRAgent/ ├── try-fix/ │ ├── content.md # Phase 2 summary │ └── attempt-{N}/ # Per-model attempt -│ ├── approach.md # What was tried -│ ├── result.txt # Pass / Fail / Blocked -│ ├── fix.diff # git diff of changes -│ └── analysis.md # Why it worked/failed +│ ├── baseline.log # Baseline establishment proof +│ ├── approach.md # What was tried +│ ├── result.txt # Pass / Fail / Blocked +│ ├── fix.diff # git diff of changes +│ ├── test-output.log # Full test command output +│ ├── reviewer-findings.json # Inline expert self-review (`[]` if clean) — reflects the FINAL diff (refreshed by Step 7.5 if test loop modified code) +│ ├── reviewer-findings.diff # Snapshot of the diff that the self-review evaluated (used by Step 7.5 to detect drift) +│ └── analysis.md # Why it worked/failed + self-review summary └── report/ └── content.md # Phase 3 output (pr-report) ``` diff --git a/.github/skills/try-fix/SKILL.md b/.github/skills/try-fix/SKILL.md index ca1fcdfc4089..e421eabffed5 100644 --- a/.github/skills/try-fix/SKILL.md +++ b/.github/skills/try-fix/SKILL.md @@ -26,7 +26,7 @@ If the prompt does not include a **problem to fix** and a **test command to veri 4. **Empirical** - Actually implement and test, don't just theorize 5. **Context-driven** - Work with what's provided and git history; don't search external sources -**Every invocation:** Review existing fixes → Think of DIFFERENT approach → Implement and test → Report results +**Every invocation runs all 11 Workflow steps below.** Step 6 (Expert Self-Review) is performed inline against `.github/agents/maui-expert-reviewer.md` — do NOT spawn the `@maui-expert-reviewer` sub-agent. Step 7.5 refreshes the self-review if the test loop modified code so the recorded findings reflect the final diff. Step 8 enforces this via a file-existence gate on `reviewer-findings.json`. ## ⚠️ CRITICAL: Sequential Execution Only @@ -69,6 +69,7 @@ Results reported back to the invoker: | `result` | `Pass`, `Fail`, or `Blocked` | | `analysis` | Why it worked, or why it failed and what was learned | | `diff` | The actual code changes made (for review) | +| `findings_count` | Number of self-review findings recorded (0 = clean self-review) | ## Output Structure (MANDATORY) @@ -96,10 +97,12 @@ Write-Host "Output directory: $OUTPUT_DIR" |------|----------------|---------| | `baseline.log` | After Step 2 (Baseline) | Output from EstablishBrokenBaseline.ps1 proving baseline was established | | `approach.md` | After Step 4 (Design) | What fix you're attempting and why it's different from existing fixes | -| `result.txt` | After Step 6 (Test) | Single word: `Pass`, `Fail`, or `Blocked` | -| `fix.diff` | After Step 6 (Test) | Output of `git diff` showing your changes | -| `test-output.log` | After Step 6 (Test) | Full output from test command | -| `analysis.md` | After Step 6 (Test) | Why it worked/failed, insights learned | +| `reviewer-findings.json` | After Step 6 (Self-Review), refreshed by Step 7.5 | JSON array of self-review findings — `[]` when clean. **MUST reflect the final diff.** | +| `reviewer-findings.diff` | After Step 6 (Self-Review), refreshed by Step 7.5 | Snapshot of `git diff` at the time the self-review was written. Step 7.5 compares this to the post-test-loop diff to detect drift. | +| `result.txt` | After Step 7 (Test) | Single word: `Pass`, `Fail`, or `Blocked` | +| `fix.diff` | After Step 7 (Test) | Output of `git diff` showing your changes | +| `test-output.log` | After Step 7 (Test) | Full output from test command | +| `analysis.md` | After Step 8 (Capture) | Why it worked/failed, insights learned, and a one-line self-review summary | **Example approach.md:** ```markdown @@ -125,10 +128,11 @@ The skill is complete when: - [ ] ONE fix approach designed and implemented - [ ] Fix tested with provided test command (iterated up to 3 times if errors/failures) - [ ] Either: Tests PASS ✅, or exhausted attempts and documented why approach won't work ❌ +- [ ] **Expert self-review performed inline (Step 6) and `reviewer-findings.json` written** — `[]` if clean. **Refreshed by Step 7.5 if the test loop modified code, so the saved findings reflect the final diff.** - [ ] Analysis provided (success explanation or failure reasoning with evidence) -- [ ] Artifacts saved to output directory +- [ ] Artifacts saved to output directory (verified by Step 8 file-existence gate) - [ ] Baseline restored (working directory clean) -- [ ] Results reported to invoker +- [ ] Results reported to invoker (including `findings_count`) 🚨 **CRITICAL: What counts as "Pass" vs "Fail"** @@ -261,7 +265,86 @@ Based on your analysis and any provided hints, design a single fix approach: Implement your fix. Use `git status --short` and `git diff` to track changes. -### Step 6: Test and Iterate (MANDATORY) +### Step 6: Expert Self-Review (MANDATORY — runs BEFORE testing) + +🚨 **You perform this self-review yourself. Do NOT spawn the `@maui-expert-reviewer` sub-agent.** Step 8's file-existence gate enforces that `reviewer-findings.json` is written every attempt. + +This step runs BEFORE testing so you can catch design flaws before spending time on build+test cycles. + +**Procedure:** + +1. **Read the rules.** View these specific sections of `.github/agents/maui-expert-reviewer.md`: + - **`## Overarching Principles`** (8 numbered principles, near the top of the file) — apply to every fix + - **`## Dimension Routing`** + **`### Always-Active Dimensions`** — pick the dimensions that match your changed files + - For each routed dimension, jump to its CHECK list under `## Review Dimensions` (e.g., `### 1. Layout Measure-Arrange Correctness`) + + You only need the dimensions that match the files you actually touched plus the always-active ones — typically 3–6 sections, not all 30. + +2. **Identify your changed files:** + ```powershell + git diff --name-only HEAD + ``` + + If you have NO code changes (e.g., Blocked because no device available before any fix was applied), still proceed to step 4 and write `'[]'` — the artifact gate is the enforcement mechanism. + +3. **Walk your diff against the rules:** + - For each Overarching Principle → does your diff violate it? + - For each routed dimension → walk every CHECK rule against the relevant hunks + - Always-Active dimensions (Logic and Correctness, Regression Prevention, Complexity Reduction) → apply regardless of file paths + - Be honest. If unsure, flag it. + +4. **Write findings to `$OUTPUT_DIR/reviewer-findings.json`.** Always write the file, even when there are zero findings. Use the same JSON format as the `@maui-expert-reviewer` agent (matches the GitHub Pull Request Review API): + + ```powershell + # No findings — clean self-review (or no diff to review): + '[]' | Set-Content "$OUTPUT_DIR/reviewer-findings.json" + + # With findings — JSON array of {path, line, body}: + @' + [ + { + "path": "src/Core/src/Handlers/ScrollView/ScrollViewHandler.iOS.cs", + "line": 42, + "body": "**[major] Layout Measure-Arrange** — Content measured with unconstrained height but arranged with bounded height. Concrete scenario: ScrollView inside a Grid with Star row height." + } + ] + '@ | Set-Content "$OUTPUT_DIR/reviewer-findings.json" + ``` + + Each entry has exactly 3 fields: + - **`path`** (string) — file relative to repo root, must be a file present in your diff + - **`line`** (integer ≥ 1) — line number on the changed (right) side of the diff. The line MUST appear in your diff — picking an unchanged line is wrong. Use `1` only as a fallback for file-level concerns where no single line captures the issue (e.g., missing import, structural concern). + - **`body`** (string) — format `**[severity] Dimension** — description`. Severity is one of `critical`/`major`/`moderate`/`minor`. + +5. **Validate the JSON parses and capture the count:** + ```powershell + try { + $findings = @(Get-Content "$OUTPUT_DIR/reviewer-findings.json" -Raw | ConvertFrom-Json) + $findingsCount = $findings.Count + Write-Host "✅ reviewer-findings.json: $findingsCount findings" + } catch { + Write-Host "❌ reviewer-findings.json is invalid JSON: $_" + throw + } + + # Snapshot the diff that was reviewed — Step 7.5 uses this to detect whether the test loop mutated code. + # Use Set-Content -Value with Out-String so the file is created even when the diff is empty + # (a bare `git diff | Set-Content` does NOT create the file when the pipe is empty). + Set-Content -Path "$OUTPUT_DIR/reviewer-findings.diff" -Value (git diff | Out-String) -NoNewline + ``` + + **Remember `$findingsCount`** — you will report it as `findings_count` in Step 10 and summarize it in `analysis.md` (Step 8). + +6. **Fix critical/major findings BEFORE testing:** + - If there are any `[critical]` or `[major]` findings → apply fixes for them in a single batch and rewrite `reviewer-findings.json` to reflect the new diff. + - All `[moderate]` and `[minor]` findings → note in `analysis.md` (Step 8); do NOT iterate. + - Only ONE correction round. Then proceed to Step 7 (Test). + +**Threshold guidance.** Only record findings with a concrete failing scenario. Stylistic preferences and bikeshedding (see the **`## What NOT to Flag`** table in `maui-expert-reviewer.md`) are not findings. An empty `[]` is the correct output for a clean fix — do not invent findings to fill the file. + +> **Why before testing?** Self-review catches design flaws (wrong null check, missing platform guard, thread safety issue) before you spend 5-15 minutes on a build+test cycle. It also runs when context is lightest — before test output floods the context window. + +### Step 7: Test and Iterate (MANDATORY) 🚨 **CRITICAL: ALWAYS use the provided test command script - NEVER manually build/compile.** @@ -286,7 +369,7 @@ pwsh .github/skills/run-device-tests/scripts/Run-DeviceTests.ps1 -Project **Why no programmatic "did you actually rewrite the JSON" check?** A SHA256 hash sentinel rejects the legitimate byte-identical case (e.g., `[]` → `[]` after a small compile fix that introduces no new violations), and that case is common. The procedural enforcement is sub-step 2's explicit numbered list above, plus the example-invocation chain that walks the dimensions explicitly. If sub-step 2 is skipped, the JSON validates but ships a stale review — accept that risk in exchange for not blocking valid clean fixes. + +**Severity handling is the same as Step 6.** If the refresh surfaces new `[critical]` or `[major]` findings, you may apply ONE more fix batch and re-run the test loop, then re-refresh. Do not loop indefinitely — if a fix introduces critical findings on the third pass, mark the attempt `Blocked` and explain in `analysis.md`. + +### Step 8: Capture Artifacts (MANDATORY) **Before reverting, save ALL required files to `$OUTPUT_DIR`:** @@ -307,13 +446,18 @@ See [references/compile-errors.md](references/compile-errors.md) for error patte # 1. Save result (MUST be exactly "Pass", "Fail", or "Blocked") "Pass" | Set-Content "$OUTPUT_DIR/result.txt" # or "Fail" -# 2. Save the diff -git diff | Set-Content "$OUTPUT_DIR/fix.diff" +# 2. Save the diff (use Set-Content -Value with Out-String so the file is created +# even when the diff is empty — a bare `git diff | Set-Content` does not create +# the file when the pipe is empty, which would fail the artifact gate.) +Set-Content -Path "$OUTPUT_DIR/fix.diff" -Value (git diff | Out-String) -NoNewline -# 3. Save test output (should already exist from Step 6) +# 3. Save test output (should already exist from Step 7) # Copy-Item "path/to/test-output.log" "$OUTPUT_DIR/test-output.log" -# 4. Save analysis +# 4. reviewer-findings.json should already exist from Step 6 (and may have been refreshed by Step 7.5) +# 4b. reviewer-findings.diff snapshot (used by Step 7.5 to detect drift) + +# 5. Save analysis (include a one-line summary of self-review findings) @" ## Analysis @@ -323,23 +467,46 @@ git diff | Set-Content "$OUTPUT_DIR/fix.diff" **Why it worked/failed:** [Root cause analysis] +**Self-review:** [N findings: brief summary of each, or "clean — no findings"] + **Insights:** [What was learned that could help future attempts] "@ | Set-Content "$OUTPUT_DIR/analysis.md" ``` -**Verify all required files exist:** +**Verify all required files exist (this is the enforcement gate for Steps 6 and 7 — primarily `reviewer-findings.json` from Step 6, refreshed by Step 7.5 if needed):** + +🚨 **The artifact check below MUST be wrapped so that Step 9 (Restore) ALWAYS runs even if the check fails.** A failed gate that skips restore would leave the worktree dirty and corrupt the next sequential try-fix attempt. + ```powershell -@("baseline.log", "approach.md", "result.txt", "fix.diff", "analysis.md", "test-output.log") | ForEach-Object { - if (Test-Path "$OUTPUT_DIR/$_") { Write-Host "✅ $_" } - else { Write-Host "❌ MISSING: $_" } +# Run the file-existence check, but DEFER any throw until after Step 9 has restored the worktree. +$missing = @() +@("baseline.log", "approach.md", "result.txt", "fix.diff", "analysis.md", "test-output.log", "reviewer-findings.json", "reviewer-findings.diff") | ForEach-Object { + if (Test-Path "$OUTPUT_DIR/$_") { + Write-Host "✅ $_" + } else { + Write-Host "❌ MISSING: $_" + $missing += $_ + } +} + +# Record the gate result for use after Step 9 — DO NOT throw here. +if ($missing.Count -gt 0) { + $gateFailureMessage = "Required artifacts missing: $($missing -join ', '). If 'reviewer-findings.json' is missing, Step 6 (Expert Self-Review) was not performed (or Step 7.5 did not refresh it after the test loop) — it is mandatory and must contain at least '[]' that reflects the final diff." + Write-Host "⚠️ ARTIFACT GATE FAILED — proceeding to Step 9 restore before reporting failure." + Write-Host $gateFailureMessage + "Blocked" | Set-Content "$OUTPUT_DIR/result.txt" -Force +} else { + $gateFailureMessage = $null } ``` +**If `$gateFailureMessage` was set:** Step 9 still runs (do NOT skip it). After Step 9 restores the worktree, surface the failure in Step 10's report — set `result.txt` to `Blocked` (already done above) and explain in `analysis.md` which artifact was missing. The next sequential attempt then starts from a clean worktree. + **Analysis quality matters.** Bad: "Didn't work". Good: "Fix attempted to reset state in OnPageSelected, but this fires after layout measurement. The cached value was already used." -### Step 8: Restore Working Directory (MANDATORY) +### Step 9: Restore Working Directory (MANDATORY — runs even if Step 8 gate failed) -**ALWAYS restore, even if fix failed.** +**ALWAYS restore, even if fix failed or Step 8 detected missing artifacts.** Skipping restore corrupts the next sequential try-fix attempt. ```bash pwsh .github/scripts/EstablishBrokenBaseline.ps1 -Restore @@ -347,7 +514,7 @@ pwsh .github/scripts/EstablishBrokenBaseline.ps1 -Restore 🚨 Use `EstablishBrokenBaseline.ps1 -Restore` — not `git checkout`, `git restore`, or `git reset` (see Step 2 for why). -### Step 9: Report Results +### Step 10: Report Results Provide structured output to the invoker: @@ -361,6 +528,8 @@ Provide structured output to the invoker: **Result:** ✅ PASS / ❌ FAIL +**Self-Review:** N findings (X critical, Y major, Z moderate/minor) — see `reviewer-findings.json` + **Analysis:** [Why it worked, or why it failed and what was learned] @@ -381,7 +550,7 @@ Provide structured output to the invoker: | Test command fails to run | Report build/setup error with details | | Test times out | Report timeout, include partial output | | Can't determine fix approach | Report "no viable approach identified" with reasoning | -| Git state unrecoverable | Run `pwsh .github/scripts/EstablishBrokenBaseline.ps1 -Restore` (see Step 2/8) | +| Git state unrecoverable | Run `pwsh .github/scripts/EstablishBrokenBaseline.ps1 -Restore` (see Step 2/9) | --- diff --git a/.github/skills/try-fix/references/example-invocation.md b/.github/skills/try-fix/references/example-invocation.md index 112f8b7ce069..362077a665c1 100644 --- a/.github/skills/try-fix/references/example-invocation.md +++ b/.github/skills/try-fix/references/example-invocation.md @@ -23,4 +23,4 @@ hints: | - Focus on the Disconnect/Cleanup methods ``` -**Skill execution:** Reads context → Analyzes target files → Designs fix (add IsDisposed check) → Applies fix → Runs test (PASS) → Reports result → Reverts changes +**Skill execution:** Reads context → Analyzes target files → Designs fix (add IsDisposed check) → Applies fix → Performs inline expert self-review against `.github/agents/maui-expert-reviewer.md` rules and writes `reviewer-findings.json` (`[]` if clean) → Runs test (PASS) → If code changed during the test loop, refreshes `reviewer-findings.json` against the final diff → Captures artifacts → Reverts changes → Reports result diff --git a/.github/skills/verify-tests-fail-without-fix/scripts/verify-tests-fail.ps1 b/.github/skills/verify-tests-fail-without-fix/scripts/verify-tests-fail.ps1 index 168f9211bf9e..c623c8a8860f 100644 --- a/.github/skills/verify-tests-fail-without-fix/scripts/verify-tests-fail.ps1 +++ b/.github/skills/verify-tests-fail-without-fix/scripts/verify-tests-fail.ps1 @@ -622,8 +622,42 @@ function Get-TestResultFromOutput { } # Check for build failures (before any test results) + # Mark these explicitly with BuildError = $true so Write-MarkdownReport can + # surface them as "Fix does not compile" instead of "Fix does not pass the tests". if ($content -match "Build FAILED" -or $content -match "Build failed with exit code" -or $content -match "error MSB\d+" -or $content -match "error CS\d+") { - return @{ Passed = $false; Error = "Build failed before tests could run"; FailCount = 0; Failed = 0; Total = 0; Skipped = 0 } + # Capture the first compile error so the diagnosis is concrete. + $buildErrorExcerpt = $null + $errMatch = [regex]::Match($content, '(?m)^.*\b(error CS\d+|error MSB\d+)\b.*$') + if ($errMatch.Success) { + $excerpt = $errMatch.Value.Trim() + if ($excerpt.Length -gt 200) { $excerpt = $excerpt.Substring(0, 200) + "..." } + $buildErrorExcerpt = $excerpt + } + return @{ + Passed = $false; BuildError = $true + Error = if ($buildErrorExcerpt) { "Build failed: $buildErrorExcerpt" } else { "Build failed before tests could run" } + FailureMessage = $buildErrorExcerpt + FailCount = 0; Failed = 0; Total = 0; Skipped = 0 + } + } + + # Check for filter mismatch — the test runner ran successfully but the supplied + # -filter expression matched zero test cases. Without this branch the gate + # would treat "0 tests ran" as ENV ERROR (or worse, silently as a failed + # test) — both misclassifications. The fix is to surface this as a separate + # "FilterMismatch" outcome so Write-MarkdownReport can label it accurately. + if ($content -match 'No test matches the given testcase filter' -or + $content -match '(?im)^\s*Test count:\s*0\b') { + $attemptedFilter = $null + $fmMatch = [regex]::Match($content, "No test matches the given testcase filter '([^']+)'") + if ($fmMatch.Success) { $attemptedFilter = $fmMatch.Groups[1].Value } + elseif ($TestFilter) { $attemptedFilter = $TestFilter } + return @{ + Passed = $false; FilterMismatch = $true + Error = if ($attemptedFilter) { "Test filter '$attemptedFilter' matched 0 tests" } else { "Test filter matched 0 tests" } + FailureMessage = $attemptedFilter + FailCount = 0; Failed = 0; Total = 0; Skipped = 0 + } } # --- Device test output: [PASS]/[FAIL] markers from xharness --- @@ -1153,11 +1187,74 @@ function Write-MarkdownReport { $status = if ($hasEnvError) { "⚠️ ENV ERROR" } elseif ($VerificationPassed) { "✅ PASSED" } else { "❌ FAILED" } $mergeBaseShort = if ($ReportMergeBase -and $ReportMergeBase.Length -ge 8) { $ReportMergeBase.Substring(0, 8) } else { "$ReportMergeBase" } + # ─── Improvement #2: classify the failure mode so the headline matches the cause ─── + # Without this, every non-PASSED gate just says "tests did not behave as expected". + # Map the without/with-fix outcomes per test into a concrete diagnosis the + # downstream Try-Fix×4 stage and the human reader can act on. + # + # Reliability extensions: + # - BuildError flag → headline says "Fix does not compile" (was conflated + # with "Fix does not pass the tests" because the test runner can't load + # an assembly that doesn't compile, so every test in it appears to fail). + # - FilterMismatch flag → headline says "Test filter matched 0 tests" + # (was misclassified as ENV ERROR or as a generic FAIL because zero + # tests ran but exit code was non-zero). + $failureClassification = $null + if (-not $hasEnvError -and -not $VerificationPassed -and $WithoutFixResultsList -and $WithFixResultsList) { + # Build error in the with-fix run trumps every other classification — if + # the fix doesn't compile, no per-test outcome is meaningful. + $wBuildError = @($WithFixResultsList | Where-Object { $_.BuildError }) + $woBuildError = @($WithoutFixResultsList | Where-Object { $_.BuildError }) + $wFilterMiss = @($WithFixResultsList | Where-Object { $_.FilterMismatch }) + $woFilterMiss = @($WithoutFixResultsList | Where-Object { $_.FilterMismatch }) + + $woStates = @($WithoutFixResultsList | ForEach-Object { if ($_.EnvError) { "ENV" } elseif ($_.BuildError) { "BUILD" } elseif ($_.FilterMismatch) { "NOMATCH" } elseif ($_.Passed) { "PASS" } else { "FAIL" } }) + $wStates = @($WithFixResultsList | ForEach-Object { if ($_.EnvError) { "ENV" } elseif ($_.BuildError) { "BUILD" } elseif ($_.FilterMismatch) { "NOMATCH" } elseif ($_.Passed) { "PASS" } else { "FAIL" } }) + + $allWoPass = ($woStates | Where-Object { $_ -ne "PASS" }).Count -eq 0 + $allWoFail = ($woStates | Where-Object { $_ -ne "FAIL" }).Count -eq 0 + $allWFail = ($wStates | Where-Object { $_ -ne "FAIL" }).Count -eq 0 + $hasRegression = $false + # Regression: at least one test fixes (FAIL→PASS) AND at least one regresses (FAIL→FAIL) + for ($i = 0; $i -lt $woStates.Count -and $i -lt $wStates.Count; $i++) { + if ($woStates[$i] -eq "FAIL" -and $wStates[$i] -eq "FAIL") { $hasRegression = $true } + } + $hasFixedTest = $false + for ($i = 0; $i -lt $woStates.Count -and $i -lt $wStates.Count; $i++) { + if ($woStates[$i] -eq "FAIL" -and $wStates[$i] -eq "PASS") { $hasFixedTest = $true } + } + + if ($wBuildError.Count -gt 0) { + $excerpt = ($wBuildError | ForEach-Object { $_.FailureMessage } | Where-Object { $_ } | Select-Object -First 1) + $excerptLine = if ($excerpt) { "`n> ``$excerpt``" } else { "" } + $failureClassification = "🩺 **Fix does not compile** — applying the PR's fix produces a build error before tests can run. The earlier-than-test failure is the root cause; the per-test ❌ FAIL marks are downstream effects, not real test failures.$excerptLine" + } elseif ($woBuildError.Count -gt 0) { + $failureClassification = "🩺 **Base branch does not compile** — the without-fix build failed. The gate's ""does the test fail without the fix"" check is unreliable here; this usually means ``main`` is broken or a merge-base file went missing. Investigate before trusting this gate." + } elseif ($wFilterMiss.Count -gt 0 -or $woFilterMiss.Count -gt 0) { + $missing = ($wFilterMiss + $woFilterMiss | ForEach-Object { $_.FailureMessage } | Where-Object { $_ } | Select-Object -First 1) + $hint = if ($missing) { " — filter ``$missing`` matched 0 tests" } else { "" } + $failureClassification = "🩺 **Test filter mismatch**$hint. The test runner produced zero results because no test class or method matched the filter. Common causes: the gate filter was derived from the file name but the actual test class is named differently, or the test was renamed/moved without updating the auto-detection. Verify the test class name matches what the gate is searching for." + } elseif ($allWoPass) { + $failureClassification = "🩺 **Test does not reproduce the bug** — ran the same in both states (PASS without fix, PASS with fix). The repro test is not exercising the issue. Strengthen the test before reviewing the fix." + } elseif ($allWoFail -and $allWFail) { + $failureClassification = "🩺 **Fix does not pass the tests** — every test still fails after applying the fix. The PR's change does not resolve the failure(s)." + } elseif ($hasFixedTest -and $hasRegression) { + $failureClassification = "🩺 **Regression in another test** — at least one test goes FAIL→PASS (fix works there), but another test FAILs both with and without the fix. The fix breaks a pre-existing or sibling test." + } elseif ($hasRegression -and -not $hasFixedTest) { + $failureClassification = "🩺 **Fix breaks tests** — one or more tests fail with the fix applied, and none of the failures are resolved by the fix." + } + # else: leave $failureClassification unset; the per-test table + Failure Details below tell the story. + } + $lines = @() $lines += "### Gate Result: $status" $lines += "" $platformDisplay = if ($ReportPlatform) { $ReportPlatform.ToUpper() } else { "N/A" } $lines += "**Platform:** $platformDisplay · **Base:** $ReportBaseBranch · **Merge base:** ``$mergeBaseShort``" + if ($failureClassification) { + $lines += "" + $lines += $failureClassification + } $lines += "" # ── Side-by-side per-test comparison table ── @@ -1172,6 +1269,10 @@ function Write-MarkdownReport { $woDur = if ($woResult.Duration) { "$([math]::Round($woResult.Duration.TotalSeconds))s" } else { "" } if ($woResult.EnvError) { $woCell = "⚠️ ENV ERROR" + } elseif ($woResult.BuildError) { + $woCell = "🛠️ BUILD ERROR" + } elseif ($woResult.FilterMismatch) { + $woCell = "🔍 NO MATCH" } elseif (-not $woResult.Passed) { $woCell = "✅ FAIL — $woDur" } else { @@ -1182,6 +1283,10 @@ function Write-MarkdownReport { $wDur = if ($wResult.Duration) { "$([math]::Round($wResult.Duration.TotalSeconds))s" } else { "" } if ($wResult.EnvError) { $wCell = "⚠️ ENV ERROR" + } elseif ($wResult.BuildError) { + $wCell = "🛠️ BUILD ERROR" + } elseif ($wResult.FilterMismatch) { + $wCell = "🔍 NO MATCH" } elseif ($wResult.Passed) { $wCell = "✅ PASS — $wDur" } else { @@ -1203,7 +1308,7 @@ function Write-MarkdownReport { # Without fix log $woLogFile = Join-Path $OutputPath "test-without-fix-$sanitizedName.log" - $woStatus = if ($woResult.EnvError) { "⚠️ ENV ERROR" } elseif (-not $woResult.Passed) { "FAIL ✅" } else { "PASS ❌" } + $woStatus = if ($woResult.EnvError) { "⚠️ ENV ERROR" } elseif ($woResult.BuildError) { "🛠️ BUILD ERROR" } elseif ($woResult.FilterMismatch) { "🔍 NO MATCH" } elseif (-not $woResult.Passed) { "FAIL ✅" } else { "PASS ❌" } $woDur = if ($woResult.Duration) { " · $([math]::Round($woResult.Duration.TotalSeconds))s" } else { "" } $lines += "" $lines += "
" @@ -1232,7 +1337,7 @@ function Write-MarkdownReport { # With fix log $wLogFile = Join-Path $OutputPath "test-with-fix-$sanitizedName.log" - $wStatus = if ($wResult.EnvError) { "⚠️ ENV ERROR" } elseif ($wResult.Passed) { "PASS ✅" } else { "FAIL ❌" } + $wStatus = if ($wResult.EnvError) { "⚠️ ENV ERROR" } elseif ($wResult.BuildError) { "🛠️ BUILD ERROR" } elseif ($wResult.FilterMismatch) { "🔍 NO MATCH" } elseif ($wResult.Passed) { "PASS ✅" } else { "FAIL ❌" } $wDur = if ($wResult.Duration) { " · $([math]::Round($wResult.Duration.TotalSeconds))s" } else { "" } $lines += "" $lines += "
" @@ -1262,13 +1367,31 @@ function Write-MarkdownReport { # ── Failure details (shown directly — not collapsed) ── $failureLines = @() foreach ($r in $WithoutFixResultsList) { - if ($r.Passed) { + if ($r.BuildError) { + $failureLines += "- 🛠️ **$($r.TestName)** without fix: build failed before tests could run" + if ($r.FailureMessage) { + $msg = if ($r.FailureMessage.Length -gt 300) { $r.FailureMessage.Substring(0, 300) + "..." } else { $r.FailureMessage } + $failureLines += " - ``$msg``" + } + } elseif ($r.FilterMismatch) { + $failureLines += "- 🔍 **$($r.TestName)** without fix: test filter matched 0 tests" + if ($r.FailureMessage) { $failureLines += " - filter: ``$($r.FailureMessage)``" } + } elseif ($r.Passed) { $failureLines += "- ❌ **$($r.TestName)** PASSED without fix (should fail) — tests don't catch the bug" } if ($r.EnvError) { $failureLines += "- ⚠️ **$($r.TestName)** without fix: ``$($r.Error)``" } } foreach ($r in $WithFixResultsList) { - if (-not $r.Passed -and -not $r.EnvError) { + if ($r.BuildError) { + $failureLines += "- 🛠️ **$($r.TestName)** with fix: build failed (fix does not compile)" + if ($r.FailureMessage) { + $msg = if ($r.FailureMessage.Length -gt 300) { $r.FailureMessage.Substring(0, 300) + "..." } else { $r.FailureMessage } + $failureLines += " - ``$msg``" + } + } elseif ($r.FilterMismatch) { + $failureLines += "- 🔍 **$($r.TestName)** with fix: test filter matched 0 tests" + if ($r.FailureMessage) { $failureLines += " - filter: ``$($r.FailureMessage)``" } + } elseif (-not $r.Passed -and -not $r.EnvError) { $failureLines += "- ❌ **$($r.TestName)** FAILED with fix (should pass)" if ($r.FailureReason) { $failureLines += " - ``$($r.FailureReason)``" } if ($r.FailureMessage) { @@ -1280,10 +1403,10 @@ function Write-MarkdownReport { } if ($failureLines.Count -gt 0) { - # Count actual failed tests (lines beginning with "- ❌" or "- ⚠️") to decide - # whether to collapse. Sub-bullets (FailureReason / FailureMessage) start with - # two leading spaces so they don't match. - $failedTestCount = @($failureLines | Where-Object { $_ -match '^- (❌|⚠️)' }).Count + # Count actual failed tests (lines beginning with "- ❌"/"- ⚠️"/"- 🛠️"/"- 🔍") + # to decide whether to collapse. Sub-bullets (FailureReason / FailureMessage) + # start with two leading spaces so they don't match. + $failedTestCount = @($failureLines | Where-Object { $_ -match '^- (❌|⚠️|🛠️|🔍)' }).Count # Threshold: if more than 5 tests failed, collapse the section so the gate # summary stays visible above the fold in PR comments. Below the threshold, # show details inline so reviewers don't need an extra click. diff --git a/eng/pipelines/ci-copilot.yml b/eng/pipelines/ci-copilot.yml index 165cb94cd6c0..2f77543be29d 100644 --- a/eng/pipelines/ci-copilot.yml +++ b/eng/pipelines/ci-copilot.yml @@ -649,6 +649,7 @@ stages: COPILOT_GITHUB_TOKEN: $(COPILOT_TOKEN) GH_TOKEN: $(GH_COMMENT_TOKEN) DEVICE_UDID: $(DEVICE_UDID) + COMMENTS_VIA_FILE: "true" # Publish Copilot logs and session artifacts - task: PublishPipelineArtifact@1 From 35f2271a8c73adc59bf89a9ae7cecd1ad3527c53 Mon Sep 17 00:00:00 2001 From: Adam Essenmacher Date: Mon, 11 May 2026 04:09:49 -0400 Subject: [PATCH 5/5] Fix iOS 26 Stepper landscape overlap --- .../EditorNoOverlapAfterRotateToLandscape.png | Bin 132061 -> 132161 bytes .../Handlers/Stepper/StepperHandler.iOS.cs | 9 +++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/Controls/tests/TestCases.iOS.Tests/snapshots/ios-26/EditorNoOverlapAfterRotateToLandscape.png b/src/Controls/tests/TestCases.iOS.Tests/snapshots/ios-26/EditorNoOverlapAfterRotateToLandscape.png index e2cdf421f6cd379c3017bc23bcc8eb4d266c2bdb..bf872a9085b36e6e07a84df44e1f62e2d3721f4f 100644 GIT binary patch delta 44675 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 YN$fgr;=kLWmV})H3M%p`drn>afA>h=IsgCw delta 44463 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 { // Trailing glass pill overflow (pts) added to UIStepper width in landscape on iOS 26+. - // No UIKit API exposes this value; measured empirically on iOS 26.1. + // No UIKit API exposes this value; measured empirically on iOS 26.4 with a small safety margin. // If it changes in a future iOS release, update and re-verify. See: https://github.com/dotnet/maui/issues/34273 - const double iOSLiquidGlassStepperOverflow = 20; + const double iOSLiquidGlassStepperOverflow = 36; readonly StepperProxy _proxy = new(); @@ -29,9 +29,10 @@ public override Size GetDesiredSize(double widthConstraint, double heightConstra // pre-glass logical size (94×32 pts). Apple does not expose the glass overflow extent // as a measurable value; this compensation was determined empirically. // - // In landscape orientation the trailing glass overflow is ~20 pts, causing controls + // In landscape orientation the trailing glass overflow can extend past the logical size, causing controls // adjacent in a HorizontalStackLayout to appear inside the visible glass pill. // Portrait orientation has negligible overflow and needs no compensation. + // The compensation includes a small safety margin and was re-verified on iOS 26.4. // // If this value changes in a future iOS release, update iOSLiquidGlassStepperOverflow // and re-verify on the new OS version. See: https://github.com/dotnet/maui/issues/34273 @@ -242,4 +243,4 @@ void OnValueChanged(object? sender, EventArgs e) } } } -} \ No newline at end of file +}