ℹ️ About Codex in GitHub

\\n
\\n\\n[Your team has set up Codex to review pull requests in this repo](https://chatgpt.com/codex/cloud/settings/general). Reviews are triggered when you\\n- Open a pull request for review\\n- Mark a draft as ready\\n- Comment \\\"@codex review\\\".\\n\\nIf Codex has suggestions, it will comment; otherwise it will react with 👍.\\n\\n\\n\\n\\nCodex can also answer questions or update the PR. Try commenting \\\"@codex address that feedback\\\".\\n \\n

\",\"path\":null,\"side\":null,\"line\":null}{\"type\":\"pull_request_comment\",\"body\":\"Thanks @codex — all three were valid. Addressed in `fe8ccd6`:\\n\\n- **Keyword / convertibility gate (P2):** NTF004 now fires only when the argument was passed with the parameter's matching `ref`/`out`/`in` keyword *and* isn't already implicitly convertible to the interface. So `m.H(a)` (missing `ref`) and an already-`ICalc` argument no longer warn — those are plain compiler errors, not ducking near-misses.\\n- **`params` expansion (P2):** non-blocking `params` elements now bind against the array's *element* type, so a genuine near-miss like `H(ref adder, 1, 2)` is no longer suppressed.\\n- **Dedup (P3):** near-miss candidates now route through `DistinctInterpretations`, so an override and the base it hides (or a repeated candidate) collapse to one interpretation instead of reading as false ambiguity.\\n\\nThe block was refactored to mirror the normal duck path's `CollectDuckableInterpretations → DistinctInterpretations → Resolve…Sites` structure. Added tests for the omitted-keyword, already-implements, `params`, and overridden-method cases.\\n\\n---\\n_Generated by [Claude Code](https://claude.ai/code)_\",\"path\":null,\"side\":null,\"line\":null}{\"type\":\"pull_request_comment\",\"body\":\"### Summary\\n\\n* Verified the PR head `fe8ccd6` already addresses the review feedback, so I made no additional code changes, did not commit, and did not create a new PR.\\n* Confirmed NTF004 near-miss discovery now deduplicates interpretations via `DistinctInterpretations` before ambiguity rejection. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL287-L290](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L287-L290)\\n* Confirmed the ref/out/in gate now requires the matching argument keyword and suppresses NTF004 when the argument already binds implicitly to the interface. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL353-L373](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L353-L373)\\n* Confirmed expanded `params` arguments are checked against the array element type for already-bound non-blocking arguments. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL376-L383](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L376-L383)\\n* Confirmed tests cover omitted ref keyword, already-implements, expanded `params`, and overridden-method dedup cases. [tests/NTypeForge.Generator.Tests/DiagnosticTests.csL710-L799](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/tests/NTypeForge.Generator.Tests/DiagnosticTests.cs#L710-L799)\\n\\n**Testing**\\n* ✅ `git status --short` — working tree was clean.\\n* ✅ `rg -n \\\"TryGetRefKindNearMiss|DistinctInterpretations|params|RefKind\\\" src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs`\\n* ✅ `rg -n \\\"omitted|already|params|override|NTF004\\\" tests src -g\\\"*.cs\\\"`\\n* ⚠️ `dotnet test` — could not run because the container does not have the .NET SDK installed (`dotnet: command not found`).\\n\\n [View task →](https://chatgpt.com/s/cd_6a482c8a761881918425be55b35c4c5b)\",\"path\":null,\"side\":null,\"line\":null}{\"type\":\"pull_request_comment\",\"body\":\"**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Require ref-kind matches for already-bound arguments**\\n\\nWhen another by-reference parameter is present but is not the ducked near-miss, this helper accepts it based only on type conversion. For example, `H(ref ICalc c, ref int n)` called as `H(ref adder, n)` treats `n` as already bound because `int` converts to `int`, so NTF004 is emitted even though the missing `ref` on the second argument is an additional blocker; similarly, `ref` invariance can be missed for derived-to-base arguments. Please check the argument's ref kind (and exact by-ref binding semantics) before considering non-near-miss by-reference parameters already bound.\\n\\nUseful? React with 👍 / 👎.\",\"path\":\"src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs\",\"side\":\"RIGHT\",\"line\":394}{\"type\":\"pull_request_comment\",\"body\":\"**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Verify the blocked ref argument is assignable**\\n\\nThis only verifies that the caller wrote the matching `ref`/`out`/`in` keyword, but a by-reference argument also has to be an assignable variable. A call like `m.H(ref new Adder())` or `m.H(ref some.Property)` against `ref ICalc` still reaches NTF004 because the expression has the structural type, even though the compiler error is that the argument is not a valid ref/out variable rather than a ducking-only blocker. Please include the ref/out variable requirement in this near-miss gate so NTF004 stays limited to clean by-reference blockers.\\n\\nUseful? React with 👍 / 👎.\",\"path\":\"src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs\",\"side\":\"RIGHT\",\"line\":363}{\"type\":\"pull_request_comment\",\"body\":\"**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Don't expand named params arguments**\\n\\nThis treats every argument mapped to a `params` parameter as bound if it converts to the element type, but a named `params` argument is not expanded element-by-element. For example, `H(ref ICalc c, params int[] values)` called as `H(ref adder, values: 1)` is still invalid because `values:` must supply an `int[]`, yet this check accepts `1` as an `int` element and reports NTF004 even though the bad named `params` argument is an additional blocker. Only apply the element-type fallback to positional expanded `params` arguments.\\n\\nUseful? React with 👍 / 👎.\",\"path\":\"src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs\",\"side\":\"RIGHT\",\"line\":394}{\"type\":\"pull_request_comment\",\"body\":\"\\n### 💡 Codex Review\\n\\nHere are some automated review suggestions for this pull request.\\n\\n**Reviewed commit:** `fe8ccd6545`\\n \\n\\n

ℹ️ About Codex in GitHub

\",\"path\":null,\"side\":null,\"line\":null}","text_elements",[],{"_379":573,"_360":361,"_381":367},{"_382":574,"_384":-5,"_42":-5,"_385":-5,"_386":-5,"_96":307,"_92":388},[575],{"_46":569,"_92":576},"input_text",{"_379":578,"_360":361,"_381":367},{"_382":579,"_384":-5,"_42":-5,"_385":-5,"_386":-5,"_96":307,"_92":388},[580],{"_46":581,"_92":576},"\n /workspace/NTypeForge\n bash\n 2026-07-03\n Etc/UTC\n",{"_379":583,"_360":361,"_381":367},{"_382":584,"_384":-5,"_42":-5,"_385":-5,"_386":-5,"_96":585,"_92":388},[586,587],"developer",{"_46":589,"_92":576},{"_46":588,"_92":576},"\n## Skills\nA skill is a set of local instructions to follow that is stored in a `SKILL.md` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.\n### Available skills\n- imagegen: Generate or edit raster images when the task benefits from AI-created bitmap visuals such as photos, illustrations, textures, sprites, mockups, or transparent-background cutouts. Use when Codex should create a brand-new image, transform an existing image, or derive visual variants from references, and the output should be a bitmap asset rather than repo-native code or vector. Do not use when the task is better handled by editing existing SVG/vector/code-native assets, extending an established icon or logo system, or building the visual directly in HTML/CSS/canvas. (file: /opt/codex/skills/.system/imagegen/SKILL.md)\n- openai-docs: Use when the user asks how to build with OpenAI products or APIs and needs up-to-date official documentation with citations, help choosing the latest model for a use case, or model upgrade and prompt-upgrade guidance; prioritize OpenAI docs MCP tools, use bundled references only as helper context, and restrict any fallback browsing to official OpenAI domains. (file: /opt/codex/skills/.system/openai-docs/SKILL.md)\n- plugin-creator: Create and scaffold plugin directories for Codex with a required `.codex-plugin/plugin.json`, optional plugin folders/files, and baseline placeholders you can edit before publishing or testing. Use when Codex needs to create a new local plugin, add optional plugin structure, or generate or update repo-root `.agents/plugins/marketplace.json` entries for plugin ordering and availability metadata. (file: /opt/codex/skills/.system/plugin-creator/SKILL.md)\n- skill-creator: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Codex's capabilities with specialized knowledge, workflows, or tool integrations. (file: /opt/codex/skills/.system/skill-creator/SKILL.md)\n- skill-installer: Install Codex skills into $CODEX_HOME/skills from a curated list or a GitHub repo path. Use when a user asks to list installable skills, install a curated skill, or install a skill from another repo (including private repos). (file: /opt/codex/skills/.system/skill-installer/SKILL.md)\n### How to use skills\n- Discovery: The list above is the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.\n- Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.\n- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.\n- How to use a skill (progressive disclosure):\n 1) After deciding to use a skill, open its `SKILL.md`. Read only enough to follow the workflow.\n 2) When `SKILL.md` references relative paths (e.g., `scripts/foo.py`), resolve them relative to the skill directory listed above first, and only consider other paths if needed.\n 3) If `SKILL.md` points to extra folders such as `references/`, load only the specific files needed for the request; don't bulk-load everything.\n 4) If `scripts/` exist, prefer running or patching them instead of retyping large code blocks.\n 5) If `assets/` or templates exist, reuse them instead of recreating from scratch.\n- Coordination and sequencing:\n - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.\n - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.\n- Context hygiene:\n - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.\n - Avoid deep reference-chasing: prefer opening only files directly linked from `SKILL.md` unless you're blocked.\n - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.\n- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.\n","\nFilesystem sandboxing defines which files can be read or written. `sandbox_mode` is `danger-full-access`: No filesystem sandboxing - all commands are permitted. Network access is enabled.\nApproval policy is currently never. Do not provide the `sandbox_permissions` for any reason, commands will be rejected.\n","turn/started",{"_360":361,"_87":592},{"_103":-5,"_42":367,"_368":593,"_370":371,"_372":594},[],"inProgress",{"_372":596,"_360":361},{"_597":598,"_92":599},"activeFlags",[],"active","thread/started",{"_602":603},"thread",{"_604":-5,"_605":-5,"_606":607,"_608":371,"_427":428,"_609":15,"_610":-5,"_611":-5,"_612":-5,"_613":614,"_42":361,"_615":616,"_181":-5,"_617":-5,"_161":618,"_619":199,"_620":-5,"_433":621,"_372":622,"_623":-5,"_77":624,"_625":371},"agentNickname","agentRole","cliVersion","0.128.0","createdAt","ephemeral","extra","forkedFromId","gitInfo","historyMode","legacy","modelProvider","openai","parentThreadId","/opt/codex/sessions/2026/07/03/rollout-2026-07-03T21-55-52-019f29fb-2484-7173-9baa-56690ae41623.jsonl","preview","recencyAt","vscode",{"_92":376},"threadSource",[],"updatedAt",[],"messages",[629],{"_42":630,"_631":632,"_633":634,"_635":634,"_382":636,"_372":637,"_384":-5,"_638":32,"_639":640,"_641":642,"_643":-5},"a99cf763-9414-45bf-854e-f19c6a6ab2c6","author",{"_96":307,"_181":-5,"_639":652},"create_time",1783115751.781175,"update_time",{"_648":46,"_649":650},"finished_successfully","weight","metadata",{"_644":645},"recipient","all","channel","l1239dk1",{"_646":647},"inline_comments",[],"content_type","parts",[651],"Thanks @codex — round 2 all valid, fixed in `cedf4e6`:\n\n- **By-ref passthrough (P2):** a `ref`/`out`/`in` parameter that isn't the ducked near-miss now binds only when the caller used the matching keyword, the argument is an assignable variable, and its type matches exactly — so `H(ref adder, n)` (missing `ref` on `n`) and ref-invariance no longer slip through.\n- **Assignable ref argument (P2):** the blocked near-miss argument must itself be an assignable variable, so `ref new Adder()` / `ref SomeProperty` (a plain ref-variable error) no longer warns.\n- **Named `params` (P2):** the element-type fallback now applies only to positional args; a named `values: 1` must supply an `int[]`.\n\nNet effect: NTF004 stays limited to a clean sole-blocker near-miss. Added tests for all three cases.\n\n---\n_Generated by [Claude Code](https://claude.ai/code)_\nAdd NTF004 (ref/out/in duck near-miss warning) + async coverage + diagnostics docs\n\nThree related DX improvements to NTypeForge's diagnostics and coverage.\n\n## 1. NTF004 — diagnose the `ref`/`out`/`in` near-miss (`67e764f`)\n\nPreviously, an implicit call whose argument *structurally matches* an interface parameter but is passed by `ref`/`out`/`in` failed **silently** — the user got a raw `CS1503` with no hint, even though their type would otherwise duck. A generated proxy can't be passed by reference, so it genuinely can't be bridged — but that's worth *explaining*.\n\nNew **NTF004 (Warning)** does exactly that, held to the same high-confidence bar as NTF003:\n- Fires only when the argument **structurally matches** the interface and the by-ref parameter is the **sole** blocker (every other argument already binds, exactly one candidate interpretation). So it never fires on ordinary type errors — a non-matching by-ref argument stays completely silent (guard test included).\n- A **Warning**, never an error, so it explains the failure without masking the compiler's own.\n- Detection lives in `CandidateAnalyzer.TryGetRefKindNearMiss`; the model carries the ref-kind + parameter name (folded into the cache key); near-miss candidates route to a new diagnostic branch and are excluded from emit (they can't be ducked).\n\n**Ambiguity and partial matches remain deliberately silent** — that's an intentional design choice (avoid guessing / avoid restating plain type errors), now pinned by `SilentDuckFailureTests`.\n\n## 2. Async-returning members (`9785647`)\n\n`Task` / `Task` / `ValueTask` are ordinary return types to the proxy, but were untested. Adds a runtime test (`AsyncMemberDuckingTests`, awaited through the proxy via both `Duck()` and implicit ducking) and a codegen-validity case.\n\n## 3. Docs (`e961ee7` + `67e764f`)\n\nREADME gains a **\"When implicit ducking can't bridge a call\"** subsection (ref/out/in → NTF004; ambiguous/incomplete → silent) and an **NTF004** row in the Diagnostics table.\n\n## Verification\n\nNo local SDK, so CI is the check. Beyond `build` + `dotnet test`, the **`cognitive-complexity`** gate (S3776 ≤ 15) matters here — the new detection was deliberately decomposed into small helpers to stay under it. NTF004 is contained to failing calls with a ref/out/in *interface* parameter, so it won't fire (and trip `TreatWarningsAsErrors`) in the sample or runtime-test projects, whose ref/out/in params are structs or passthroughs.\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nhttps://claude.ai/code/session_01F7W1dyFLg9YmH8GpCiG7Cs\nYou have reached your Codex usage limits for code reviews. You can see your limits in the [Codex usage dashboard](https://chatgpt.com/codex/cloud/settings/usage).\nTo continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your [settings](https://chatgpt.com/codex/cloud/settings/code-review).\nCopilot was unable to review this pull request because the user who requested the review has reached their quota limit.\n@codex review this pr\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Gate NTF004 on an actual ducking blocker**\n\nWhen a call fails only because the caller omitted or mismatched the by-reference keyword, this branch still treats every `ref`/`out`/`in` interface parameter as a ducking near-miss. For example, `ICalc c; m.H(c)` against `void H(ref ICalc c)` reaches `TryBuildRefKindBlocker` and reports NTF004 even though the argument is already the interface and no generated proxy is involved; the actionable compiler error is just the missing `ref`. Please verify the argument's ref kind matches the parameter, and that the argument is not already implicitly convertible, before reporting this warning.\n\nUseful? React with 👍 / 👎.\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Treat expanded params elements as already bound**\n\nFor clean near-misses that also pass expanded `params` arguments, this check compares each expanded element to the array parameter type, so a valid call like `H(ref ICalc c, params int[] values)` invoked as `H(ref adder, 1, 2)` is rejected because `1` is not implicitly convertible to `int[]`. That suppresses NTF004 even though the `ref` duck is the only real blocker and regular implicit ducking already supports this `params` call shape; handle `params` expansion here by checking elements against the parameter element type.\n\nUseful? React with 👍 / 👎.\n**_{_{![P3 Badge](https://img.shields.io/badge/P3-lightgrey?style=flat)}} Deduplicate equivalent ref-kind near-miss candidates**\n\nThis loop treats a second qualifying raw candidate as ambiguity before applying the equivalent-candidate deduplication used by normal implicit ducking. In contexts where Roslyn reports both an override/base method or repeats a candidate (the cases handled by `DistinctInterpretations` below), a single ref/out/in near-miss is dropped and NTF004 is never reported. Please key and deduplicate the blocked candidate interpretations before returning null for ambiguity.\n\nUseful? React with 👍 / 👎.\n\n### 💡 Codex Review\n\nHere are some automated review suggestions for this pull request.\n\n**Reviewed commit:** `67e764fc99`\n \n\n

ℹ️ About Codex in GitHub

\n
\n\n[Your team has set up Codex to review pull requests in this repo](https://chatgpt.com/codex/cloud/settings/general). Reviews are triggered when you\n- Open a pull request for review\n- Mark a draft as ready\n- Comment \"@codex review\".\n\nIf Codex has suggestions, it will comment; otherwise it will react with 👍.\n\n\n\n\nCodex can also answer questions or update the PR. Try commenting \"@codex address that feedback\".\n \n

\nThanks @codex — all three were valid. Addressed in `fe8ccd6`:\n\n- **Keyword / convertibility gate (P2):** NTF004 now fires only when the argument was passed with the parameter's matching `ref`/`out`/`in` keyword *and* isn't already implicitly convertible to the interface. So `m.H(a)` (missing `ref`) and an already-`ICalc` argument no longer warn — those are plain compiler errors, not ducking near-misses.\n- **`params` expansion (P2):** non-blocking `params` elements now bind against the array's *element* type, so a genuine near-miss like `H(ref adder, 1, 2)` is no longer suppressed.\n- **Dedup (P3):** near-miss candidates now route through `DistinctInterpretations`, so an override and the base it hides (or a repeated candidate) collapse to one interpretation instead of reading as false ambiguity.\n\nThe block was refactored to mirror the normal duck path's `CollectDuckableInterpretations → DistinctInterpretations → Resolve…Sites` structure. Added tests for the omitted-keyword, already-implements, `params`, and overridden-method cases.\n\n---\n_Generated by [Claude Code](https://claude.ai/code)_\n### Summary\n\n* Verified the PR head `fe8ccd6` already addresses the review feedback, so I made no additional code changes, did not commit, and did not create a new PR.\n* Confirmed NTF004 near-miss discovery now deduplicates interpretations via `DistinctInterpretations` before ambiguity rejection. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL287-L290](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L287-L290)\n* Confirmed the ref/out/in gate now requires the matching argument keyword and suppresses NTF004 when the argument already binds implicitly to the interface. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL353-L373](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L353-L373)\n* Confirmed expanded `params` arguments are checked against the array element type for already-bound non-blocking arguments. [src/NTypeForge.SourceGenerator/CandidateAnalyzer.csL376-L383](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs#L376-L383)\n* Confirmed tests cover omitted ref keyword, already-implements, expanded `params`, and overridden-method dedup cases. [tests/NTypeForge.Generator.Tests/DiagnosticTests.csL710-L799](https://github.com/timonkrebs/NTypeForge/blob/fe8ccd6545f3a3cd72919c319933375d70c2d855/tests/NTypeForge.Generator.Tests/DiagnosticTests.cs#L710-L799)\n\n**Testing**\n* ✅ `git status --short` — working tree was clean.\n* ✅ `rg -n \"TryGetRefKindNearMiss|DistinctInterpretations|params|RefKind\" src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs`\n* ✅ `rg -n \"omitted|already|params|override|NTF004\" tests src -g\"*.cs\"`\n* ⚠️ `dotnet test` — could not run because the container does not have the .NET SDK installed (`dotnet: command not found`).\n\n [View task →](https://chatgpt.com/s/cd_6a482c8a761881918425be55b35c4c5b)\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Require ref-kind matches for already-bound arguments**\n\nWhen another by-reference parameter is present but is not the ducked near-miss, this helper accepts it based only on type conversion. For example, `H(ref ICalc c, ref int n)` called as `H(ref adder, n)` treats `n` as already bound because `int` converts to `int`, so NTF004 is emitted even though the missing `ref` on the second argument is an additional blocker; similarly, `ref` invariance can be missed for derived-to-base arguments. Please check the argument's ref kind (and exact by-ref binding semantics) before considering non-near-miss by-reference parameters already bound.\n\nUseful? React with 👍 / 👎.\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Verify the blocked ref argument is assignable**\n\nThis only verifies that the caller wrote the matching `ref`/`out`/`in` keyword, but a by-reference argument also has to be an assignable variable. A call like `m.H(ref new Adder())` or `m.H(ref some.Property)` against `ref ICalc` still reaches NTF004 because the expression has the structural type, even though the compiler error is that the argument is not a valid ref/out variable rather than a ducking-only blocker. Please include the ref/out variable requirement in this near-miss gate so NTF004 stays limited to clean by-reference blockers.\n\nUseful? React with 👍 / 👎.\n**_{_{![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)}} Don't expand named params arguments**\n\nThis treats every argument mapped to a `params` parameter as bound if it converts to the element type, but a named `params` argument is not expanded element-by-element. For example, `H(ref ICalc c, params int[] values)` called as `H(ref adder, values: 1)` is still invalid because `values:` must supply an `int[]`, yet this check accepts `1` as an `int` element and reports NTF004 even though the bad named `params` argument is an additional blocker. Only apply the element-type fallback to positional expanded `params` arguments.\n\nUseful? React with 👍 / 👎.\n\n### 💡 Codex Review\n\nHere are some automated review suggestions for this pull request.\n\n**Reviewed commit:** `fe8ccd6545`\n \n\n

ℹ️ About Codex in GitHub

",{},"created",1783115788.323638,"Completing the task","event_type","info",{"_92":388,"_96":93,"_382":1460},{"_92":660,"_661":662},"partial_repo_snapshot","files",[663,664],{"_161":944,"_666":-5,"_667":945,"_669":-5},{"_161":665,"_666":-5,"_667":668,"_669":-5},"tests/NTypeForge.Generator.Tests/DiagnosticTests.cs","contents","line_range_contents",[670],"missing_reason",{"_671":672,"_673":674,"_382":675,"_676":59},"line_range_start",1,"line_range_end",870,[677,678,679,199,680,199,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,199,698,199,699,700,701,199,683,702,685,686,687,688,689,703,704,692,693,705,695,696,697,199,698,199,700,706,701,199,683,707,685,708,709,686,687,688,689,710,711,712,692,693,713,695,696,697,199,698,199,700,706,701,199,683,714,685,715,716,686,687,688,689,717,718,719,693,720,721,695,696,697,199,698,199,706,700,701,199,683,722,685,686,687,688,689,717,718,692,693,723,695,696,697,199,698,199,706,700,701,199,724,725,726,683,727,685,686,687,688,689,728,729,692,693,730,695,696,697,199,731,732,701,199,733,683,734,685,686,687,688,689,735,736,737,696,697,199,731,732,701,199,738,683,739,685,686,687,688,689,740,741,737,696,697,199,731,732,701,199,742,743,744,683,745,685,686,687,688,689,728,746,747,696,697,199,731,732,701,199,748,749,683,750,685,686,687,688,689,751,752,753,696,697,199,731,732,701,199,754,683,755,685,686,687,688,689,756,757,758,696,697,199,731,732,701,199,759,683,760,685,686,687,688,689,761,762,763,696,697,199,731,732,701,199,764,765,683,766,685,686,687,688,689,767,729,768,696,697,199,731,732,701,199,769,683,770,685,686,687,771,688,689,772,773,774,696,697,199,731,732,701,199,775,776,777,778,683,779,685,686,687,688,689,780,781,719,693,782,783,695,696,697,199,698,784,785,701,199,786,787,683,788,685,686,687,688,689,789,719,693,782,790,791,695,696,697,199,792,701,199,793,794,683,795,685,686,687,688,689,796,797,781,719,693,798,799,783,695,696,697,199,792,701,800,801,802,803,683,804,685,686,687,688,689,805,806,781,719,693,798,799,807,695,696,697,199,808,701,199,809,810,811,812,683,813,685,686,687,688,689,814,781,815,816,817,696,697,199,808,701,199,818,819,820,683,821,685,686,687,688,689,717,822,823,824,719,693,825,826,695,696,697,199,827,808,701,199,828,829,830,683,831,685,686,687,688,689,717,780,823,781,719,693,832,833,695,696,697,199,698,784,834,701,199,835,836,683,837,685,686,687,688,689,805,806,781,719,693,838,839,840,695,696,697,199,808,701,199,841,842,843,683,844,685,686,687,688,689,717,823,845,696,697,199,846,701,199,847,848,683,849,685,686,687,688,689,850,693,851,852,695,781,853,696,697,199,846,854,732,701,199,855,856,857,858,683,859,685,686,687,688,689,860,861,862,696,697,199,731,732,701,199,863,864,683,865,685,686,687,688,689,866,867,737,696,697,199,868,732,701,199,869,870,871,683,872,685,686,687,688,689,873,874,737,696,697,199,868,701,199,875,876,683,877,685,686,687,688,689,878,879,737,696,697,199,731,732,701,199,880,881,882,883,683,884,685,686,687,688,689,717,823,719,693,885,886,695,696,697,199,887,888,889,808,890,701,199,683,891,685,686,687,688,689,717,823,719,693,892,893,695,696,697,199,887,888,894,890,701,199,683,895,685,686,687,688,689,717,823,719,693,896,897,695,696,697,199,887,888,898,890,701,199,899,900,683,901,685,686,687,688,689,717,902,719,693,885,903,695,696,697,199,827,701,199,904,905,906,683,907,685,686,687,688,689,717,823,719,693,885,908,695,696,697,199,827,701,199,909,910,683,911,685,686,687,688,689,717,912,719,693,885,913,695,696,697,199,827,701,199,914,915,683,916,685,686,687,688,689,717,823,719,693,917,918,695,696,697,199,887,888,889,701,199,919,920,683,921,685,686,687,688,689,717,823,922,923,719,693,924,695,696,697,199,925,701,199,926,927,928,683,929,685,686,687,688,689,717,823,719,693,930,931,695,696,697,199,827,701,199,932,933,934,683,935,685,686,687,688,689,717,823,719,693,885,936,695,696,697,199,827,701,199,937,938,939,683,940,685,686,687,688,689,717,823,719,693,941,942,695,696,697,199,827,701,943],"contains_end_of_file","using System.Linq;","using Microsoft.CodeAnalysis;","using Xunit;","namespace NTypeForge.Generator.Tests;","public class DiagnosticTests","{"," [Fact]"," public void NTF001_ReportedWhenDuckTargetDoesNotStructurallyMatch()"," {"," const string source = \"\"\""," using NTypeForge;"," namespace T"," {"," public interface IFoo { int Bar(); }"," public class NoMatch { public int Other() => 0; }"," public class C"," {"," public void M() { var x = new NoMatch().Duck(); }"," }"," }"," \"\"\";"," var diagnostics = GeneratorTestHarness.GetGeneratorDiagnostics(source);"," Assert.Equal(1, diagnostics.CountDiagnostics(\"NTF001\"));"," Assert.False(diagnostics.HasDiagnostic(\"NTF002\"));"," }"," public void NoDiagnostic_WhenInterfaceHasProperty()"," public interface IHasProp { int Value { get; } int Do(); }"," public class Impl { public int Value => 1; public int Do() => 2; }"," public void M() { var x = new Impl().Duck(); }"," Assert.False(diagnostics.HasDiagnostic(\"NTF001\"));"," public void NoDiagnostic_WhenInheritedInterfaceHasProperty()"," // Guards the inherited-member fix: the unsupported property lives on the"," // *base* interface, so a scan of direct members only would miss it."," public interface IBaseProp { int P { get; } }"," public interface IDerivedM : IBaseProp { int Do(); }"," public class Impl { public int P => 1; public int Do() => 2; }"," public void M() { var x = new Impl().Duck(); }"," public void NoDiagnostic_ForImplicitMethodArgumentDucking()"," // An implicit conversion failure (no Duck) is silently handled by"," // generating an extension; it must not report NTF00x."," public interface ICalc { int Add(int a, int b); }"," public class Add { public int Add(int a, int b) => a + b; }"," public class Mgr"," public int H(ICalc c) => c.Add(1, 2);"," public void M() { var m = new Mgr(); m.H(new Add()); }"," public void NoDiagnostic_ForValidDuckMatch()"," public void M() { var x = new Add().Duck(); }"," // An init-only *underlying* setter cannot be forwarded: the proxy wraps an already-constructed"," // instance, so `_instance.Value = value` would be CS8852. The generator must report a clean"," // NTF001 (no structural match) instead of emitting code that fails to compile."," public void NTF001_WhenInterfaceNeedsSetterButUnderlyingIsInitOnly()"," public interface IWritable { int Value { get; set; } }"," public class InitOnly { public int Value { get; init; } }"," public void M() { var x = new InitOnly().Duck(); }"," Assert.Equal(1, GeneratorTestHarness.GetGeneratorDiagnostics(source).CountDiagnostics(\"NTF001\"));"," Assert.Empty(GeneratorTestHarness.GetEmittedCompileErrors(source));"," // A concrete method with different parameter types from the interface method cannot satisfy it."," public void NTF001_WhenParameterTypeDiffers()"," public interface I { void Do(int a); }"," public class C { public void Do(string a) {} }"," public class U { public void M() { var x = new C().Duck(); } }"," // A concrete method with a different parameter count from the interface method cannot satisfy it."," public void NTF001_WhenParameterCountDiffers()"," public interface I { void Do(int a, int b); }"," public class C { public void Do(int a) {} }"," // Regression: a concrete with a *private* setter must not be treated as satisfying a `{ get; set; }`"," // requirement. The proxy would emit `_instance.Value = value` against an inaccessible setter"," // (CS0272). Expect a clean NTF001 with no emitted compile errors instead."," public void NTF001_WhenConcreteSetterIsPrivate()"," public class PrivateSetter { public int Value { get; private set; } }"," public class C { public void M() { var x = new PrivateSetter().Duck(); } }"," // Regression: a *private* method must not count toward structural matching - forwarding"," // `_instance.Do()` to an inaccessible method is CS0122. Expect a clean NTF001 instead."," public void NTF001_WhenConcreteMethodIsPrivate()"," public interface IDo { int Do(); }"," public class PrivateDo { private int Do() => 1; }"," public class C { public void M() { var x = new PrivateDo().Duck(); } }"," // A property whose name matches but whose type differs is not a structural match."," public void NTF001_WhenPropertyTypeDiffers()"," public interface IIntValue { int Value { get; } }"," public class HasString { public string Value { get; set; } = \"\"; }"," public class C { public void M() { var x = new HasString().Duck(); } }"," // A non-generic method cannot satisfy a generic-method requirement (arity differs)."," public void NTF001_WhenGenericMethodArityDiffers()"," public interface IGen { TItem Get(); }"," public class NonGeneric { public int Get() => 1; }"," public class C { public void M() { var x = new NonGeneric().Duck(); } }"," // An init-only interface property over an init-only underlying cannot be proxied (the setter"," // would assign to an already-constructed instance). It must report NTF001, not emit CS8852."," public void NTF001_WhenInitOnlyDuckedToInitOnly()"," public interface IInit { int Value { get; init; } }"," public class C { public void M() { var x = new InitOnly().Duck(); } }"," // A required event with no counterpart on the concrete is not a match."," public void NTF001_WhenInterfaceEventMissing()"," using System;"," public interface IPub { event Action Fired; }"," public class NoEvent { public int Other() => 1; }"," public class C { public void M() { var x = new NoEvent().Duck(); } }"," // High-confidence implicit near-miss: the concrete satisfies every proxyable member of the"," // parameter interface and the only blocker is an unsupported (static-abstract) member. The"," // generator surfaces NTF003 - as a Warning, so it explains the failure without becoming a"," // second hard error on top of the user's real call-resolution error."," public void NTF003_Warning_WhenImplicitDuckBlockedOnlyByUnsupportedMember()"," public interface IFactory { static abstract IFactory Create(); int Do(); }"," public class Impl { public int Do() => 1; }"," public void H(IFactory f) {}"," public void M() { var m = new Mgr(); m.H(new Impl()); }"," var ntf003 = diagnostics.Single(d => d.Id == \"NTF003\");"," Assert.Equal(DiagnosticSeverity.Warning, ntf003.Severity);"," // The parameter interface has no proxyable instance member, so the concrete only \"matches\" it"," // vacuously - the failed call is almost certainly unrelated to duck typing. No NTF003."," public void NTF003_NotReported_WhenInterfaceHasNoInstanceContract()"," public interface IFactory { static abstract IFactory Create(); }"," public void H(int x) {}"," public void M() { var m = new Mgr(); m.H(\"oops\"); }"," Assert.False(GeneratorTestHarness.GetGeneratorDiagnostics(source).HasDiagnostic(\"NTF003\"));"," // Two duckable interface overloads make the failed call ambiguous: NTypeForge cannot know which"," // the user meant, so it stays silent rather than guessing."," public void NTF003_NotReported_WhenDuckSiteIsAmbiguous()"," public interface IA { int Do(); static abstract IA Make(); }"," public interface IB { int Do(); static abstract IB Make(); }"," public void H(IA a) {}"," public void H(IB b) {}"," "," // Even when both overloads target *proxyable* interfaces, an ambiguous duckable call must not be"," // silently rewired: choosing one interpretation would be arbitrary (and could pick the wrong"," // overload). The generator emits no proxy, so the compiler's own ambiguity error stands."," public void AmbiguousMethodArgumentDuck_IsNotRewired()"," public interface IA { int Do(); }"," public interface IB { int Do(); }"," public void M() { new Mgr().H(new Impl()); }"," Assert.DoesNotContain(\"_Proxy_\", GeneratorTestHarness.GetGeneratedText(source));"," // Ambiguity can also come from two same-named methods on *different declaring types* (here two"," // extension methods on Impl). They share name/argument-position/parameter-shape, so the duckable"," // interpretation must be distinguished by its declaring type - otherwise they collapse to one and"," // the genuinely-ambiguous call gets rewired to an arbitrary one. No proxy must be emitted."," public void AmbiguousDuckAcrossDeclaringTypes_IsNotRewired()"," public interface IFoo { int Do(); }"," public static class A { public static void Use(this Impl x, IFoo f) {} }"," public static class B { public static void Use(this Impl x, IFoo f) {} }"," public class C { public void M() { new Impl().Use(new Impl()); } }"," // Several arguments duck in the same call only as a whole: when one of them has no structural"," // match, the site must not be bridged at all (a forwarding method ducking just the matching"," // argument could never bind), and no NTF00x may mask the compiler's own error."," public void TwoDuckableArguments_OneWithoutMatch_IsNotRewired()"," public interface ILog { string Log(string m); }"," public class Adder { public int Add(int a, int b) => a + b; }"," public class NotALogger { public int Other() => 0; }"," public string H(ICalc c, ILog l) => l.Log(c.Add(1, 2).ToString());"," public void M() { var m = new Mgr(); m.H(new Adder(), new NotALogger()); }"," Assert.Empty(GeneratorTestHarness.GetGeneratorDiagnostics(source));"," // The multi-argument near-miss: every ducked argument satisfies its proxyable contract and the"," // only blocker is one interface's unsupported (static-abstract) member - exactly one NTF003,"," // naming that argument."," public void NTF003_WhenOneOfTwoDuckedArgumentsBlockedOnlyByUnsupportedMember()"," public void H(ICalc c, IFactory f) {}"," public void M() { var m = new Mgr(); m.H(new Adder(), new Impl()); }"," Assert.Contains(\"IFactory\", ntf003.GetMessage());"," // Two overloads, each of which could fix the call by ducking both of its arguments, are still"," // ambiguous: multi-argument support must not erode the one-interpretation rule."," public void AmbiguousOverloads_WithTwoDuckableArgumentsEach_AreNotRewired()"," public void H(IA a, IB b) {}"," public void H(IB a, IA b) {}"," public void M() { var m = new Mgr(); m.H(new Impl(), new Impl()); }"," // A static-qualified `DuckExtensions.Duck(x)` cannot bind to the generated instance extension"," // member, so it is not a duck site. The analyzer must not mistake the `DuckExtensions` type for"," // the ducked instance and report a spurious NTF001 against it."," public void QualifiedStaticDuckCall_DoesNotReportNTF001()"," public class C { public void M() { var x = DuckExtensions.Duck(new Adder()); } }"," Assert.False(GeneratorTestHarness.GetGeneratorDiagnostics(source).HasDiagnostic(\"NTF001\"));"," // A static member with a default implementation is provided by the interface itself, so it is"," // not \"unsupported\" and a concrete that matches the instance contract ducks cleanly."," public void StaticMemberWithDefaultImpl_DoesNotBlockDucking()"," public interface IWithStatic"," static int Shared() => 7;"," int Do();"," public class C { public void M() { var x = new Impl().Duck(); } }"," Assert.False(GeneratorTestHarness.GetGeneratorDiagnostics(source).HasDiagnostic(\"NTF002\"));"," // A concrete generic method whose constraint is STRICTER than the interface's cannot be safely"," // proxied (the proxy would declare the looser signature and forward to the stricter method,"," // failing CS0310). Constraints are part of the match key, so this is a clean NTF001 (no match)"," // rather than emitted code that doesn't compile."," public void NTF001_WhenConcreteGenericConstraintStricterThanInterface()"," public interface IRunner { TItem Make(); }"," public class Impl { public TItem Make() where TItem : new() => new TItem(); }"," public class C { public void M() { var x = new Impl().Duck(); } }"," // A by-ref return cannot be forwarded by the proxy; the interface is unproxyable. NTF002, not"," // broken generated code (CS0535)."," public void NTF002_WhenInterfaceMethodReturnsByRef()"," public interface I { ref int Get(); }"," public class C { int _x; public ref int Get() => ref _x; }"," Assert.True(GeneratorTestHarness.GetGeneratorDiagnostics(source).HasDiagnostic(\"NTF002\"));"," // A pointer-typed member makes the interface unproxyable (the generated struct is not unsafe)."," // The generator must report NTF002 and emit no proxy (the user's own unsafe declarations need"," // /unsafe, but the generator must not add to the breakage)."," public void NTF002_WhenInterfaceMemberInvolvesPointer()"," public unsafe interface I { int* Get(); }"," public unsafe class C { public int* Get() => null; }"," // A concrete whose matching member is `static` cannot back an instance proxy (CS0176); static"," // members must not count toward the surface, so this is a clean NTF001."," public void NTF001_WhenConcreteMemberIsStatic()"," public interface I { string Greet(); }"," public class C { public static string Greet() => \"hi\"; }"," // NTF004: a by-reference near-miss. The argument structurally matches the parameter interface,"," // but the parameter is ref/out/in - a generated proxy can't be passed by reference - so the call"," // can't be bridged. A Warning explains why an otherwise-matching type was rejected; no proxy is"," // emitted and the compiler's own ref-kind error still stands."," public void NTF004_WhenDuckedArgumentIsRef()"," public int H(ref ICalc c) => c.Add(1, 2);"," public void M() { var m = new Mgr(); var a = new Adder(); m.H(ref a); }"," var ntf004 = GeneratorTestHarness.GetGeneratorDiagnostics(source).Single(d => d.Id == \"NTF004\");"," Assert.Equal(DiagnosticSeverity.Warning, ntf004.Severity);"," Assert.Contains(\"'ref'\", ntf004.GetMessage());"," Assert.NotEmpty(GeneratorTestHarness.GetEmittedCompileErrors(source));"," public void NTF004_WhenDuckedArgumentIsOut()"," public void H(out ICalc c) => c = null;"," public void M() { var m = new Mgr(); Adder a; m.H(out a); }"," Assert.Contains(\"'out'\", ntf004.GetMessage());"," public void NTF004_WhenDuckedArgumentIsIn()"," public int H(in ICalc c) => c.Add(1, 2);"," public void M() { var m = new Mgr(); var a = new Adder(); m.H(in a); }"," Assert.Contains(\"'in'\", ntf004.GetMessage());"," // No NTF004 when the by-ref argument doesn't even structurally match: that is an ordinary type"," // error, not a near-miss, so NTypeForge stays completely silent (no diagnostic at all)."," public void NTF004_NotReported_WhenByRefArgumentDoesNotStructurallyMatch()"," public class NotACalc { public int Other() => 0; }"," public void M() { var m = new Mgr(); var a = new NotACalc(); m.H(ref a); }"," // No NTF004 when the caller omits the by-reference keyword (`m.H(a)` against `ref ICalc c`): the"," // by-ref kind is not the sole blocker - the missing keyword is a plain compiler error - so this"," // is not a ducking near-miss."," public void NTF004_NotReported_WhenRefKeywordOmitted()"," public void M() { var m = new Mgr(); var a = new Adder(); m.H(a); }"," // No NTF004 when the argument already implements the interface (`Calc : ICalc`): passing it by"," // `ref` fails only on ref-type invariance, no proxy is involved, so it is not a ducking near-miss."," public void NTF004_NotReported_WhenArgumentAlreadyImplementsInterface()"," public class Calc : ICalc { public int Add(int a, int b) => a + b; }"," public void M() { var m = new Mgr(); var a = new Calc(); m.H(ref a); }"," // NTF004 still fires for a near-miss whose call also uses expanded `params` arguments: the params"," // elements bind against the element type, so the `ref` duck remains the sole blocker."," public void NTF004_WhenParamsArgumentsBindByElement()"," public int H(ref ICalc c, params int[] values) => c.Add(values[0], values[1]);"," public void M() { var m = new Mgr(); var a = new Adder(); m.H(ref a, 1, 2); }"," // A ref/out/in near-miss on an overridden method is reported once, not dropped as ambiguity:"," // equivalent candidates collapse through DistinctInterpretations rather than counting twice."," public void NTF004_ReportedOnce_WithOverriddenMethod()"," public class Base { public virtual int H(ref ICalc c) => c.Add(1, 2); }"," public class Derived : Base { public override int H(ref ICalc c) => c.Add(3, 4); }"," public void M() { var d = new Derived(); var a = new Adder(); d.H(ref a); }"," Assert.Single(GeneratorTestHarness.GetGeneratorDiagnostics(source).Where(d => d.Id == \"NTF004\"));"," // No NTF004 when another by-reference parameter is also mis-passed: `H(ref ICalc c, ref int n)`"," // called as `H(ref adder, n)` (missing `ref` on n) has a second blocker, so the ref duck is not"," // the sole reason the call fails."," public void NTF004_NotReported_WhenAnotherByRefArgumentOmitsKeyword()"," public int H(ref ICalc c, ref int n) => c.Add(n, n);"," public void M() { var m = new Mgr(); var a = new Adder(); int n = 1; m.H(ref a, n); }"," // No NTF004 when the by-reference argument is not an assignable variable: `m.H(ref new Adder())`"," // structurally matches, but the compiler error is that a ref argument must be a variable - not a"," // ducking-only blocker."," public void NTF004_NotReported_WhenBlockedArgumentIsNotAssignable()"," public void M() { var m = new Mgr(); m.H(ref new Adder()); }"," // No NTF004 when a named params argument can't be element-expanded: `H(ref ICalc c, params int[]"," // values)` called as `H(ref adder, values: 1)` still fails on `values:` needing an int[], so the"," // ref duck is not the sole blocker."," public void NTF004_NotReported_WhenParamsArgumentIsNamed()"," public int H(ref ICalc c, params int[] values) => c.Add(values[0], values[0]);"," public void M() { var m = new Mgr(); var a = new Adder(); m.H(ref a, values: 1); }","}","src/NTypeForge.SourceGenerator/CandidateAnalyzer.cs",[946],{"_671":672,"_673":947,"_382":948,"_676":59},797,[949,950,677,951,678,952,953,954,199,955,682,956,957,958,959,960,961,962,685,963,964,965,966,967,968,969,970,971,972,973,199,974,975,689,976,977,978,979,980,981,696,982,199,983,965,984,985,986,199,987,988,199,989,990,991,199,992,993,982,199,994,995,996,997,199,998,999,1000,1001,1002,1003,1004,199,1005,965,1006,689,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1013,1017,1015,1018,1019,1020,1018,696,982,199,1021,1022,1023,1024,199,1025,965,1026,689,1027,696,1028,982,199,1029,965,1030,689,1031,693,1032,695,1033,696,199,1034,689,1035,696,199,1036,689,1037,693,1038,695,696,1039,982,199,1040,1041,1042,1043,1044,965,1045,1046,1047,199,1048,1049,199,1050,1051,199,1052,1053,1054,1055,1047,1056,1057,1058,1047,199,1059,1060,1061,1062,199,1063,1064,1065,1066,982,199,1067,965,1068,1069,1070,1071,1072,982,199,1073,1074,1075,1076,1077,1078,1079,965,1080,199,1081,1082,199,1083,982,199,1084,1085,1086,1087,1088,1089,1090,1091,1092,1043,1044,965,1093,199,1094,1095,1096,1097,1098,1099,1100,199,1101,1102,1103,1104,1105,1106,1047,199,1107,1108,199,1063,1109,1110,1111,1112,982,199,1113,1114,1115,1116,1117,1118,1119,1120,965,1121,1122,689,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,199,1135,696,199,1136,1137,982,199,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1043,1044,965,1093,199,1097,1098,1148,1100,199,1101,1102,1103,1104,1105,1106,1047,199,1063,1149,1110,1111,1112,982,199,1150,1151,1152,1153,1154,1155,1043,1156,965,1157,1158,689,1159,1160,1161,199,1162,1163,696,1164,982,199,1165,1166,1167,1168,1169,1170,1171,965,1172,1173,689,1174,1175,1176,1177,199,1178,1179,1180,1134,696,1181,982,199,1182,1183,1184,1185,1186,1187,1188,1189,965,1190,1191,1192,199,1193,1194,1195,1033,1196,1033,1197,199,1198,982,199,1199,1200,1201,1202,1203,1204,965,1205,1206,1207,199,1208,199,1209,1210,1211,1212,1213,982,199,1214,1215,1216,1217,1218,1204,965,1191,1192,1219,1220,982,199,1221,1222,1223,1224,1225,965,1226,689,1227,1228,1229,1230,696,982,199,1231,965,1232,1233,982,199,1234,1235,1236,1237,1238,1239,965,1240,1241,689,1242,1243,1244,1230,696,982,199,1245,1246,1247,1248,1120,965,1121,1122,689,1124,1176,1249,1250,1251,696,1136,1137,982,199,1252,1253,1254,1255,965,1256,1257,1258,1259,1260,982,199,1261,965,1262,689,1263,1264,1265,1266,696,982,199,1267,1268,199,1269,1270,199,1271,1272,199,1273,1274,1044,965,1275,1276,199,1277,1278,1279,982,199,1280,1281,199,1282,1283,1284,1285,1286,1287,965,1288,1289,1290,199,1291,1292,1293,689,1294,696,1295,982,199,1296,1297,1298,1299,1300,1301,1302,1303,1304,199,1305,1043,1156,965,1157,1158,689,1159,1160,1161,199,1306,1307,696,1164,982,199,1308,1309,1310,1156,965,1311,1173,689,1174,1312,1313,696,1314,982,199,1315,1316,1317,1318,1319,1170,1320,965,1321,199,1322,1323,1324,1325,1326,1327,199,1328,1329,199,1330,1331,1332,199,1333,1334,982,199,1335,1336,1337,1338,1339,1340,965,1341,689,1342,1343,696,199,1344,1345,982,199,1346,1347,965,1348,1349,199,1350,1351,1352,1353,982,199,1354,1355,965,1356,1357,1358,1359,199,1360,689,1361,199,1362,1363,696,199,1364,982,199,1365,1366,965,1367,1368,1369,982,199,1370,1371,965,1372,1373,1374,982,199,1375,1376,965,1377,1378,199,1379,689,1380,1381,1382,696,199,1383,1384,982,199,1385,965,1386,689,1387,1388,696,1028,982,199,1389,965,1390,689,1391,696,1392,982,199,1393,965,1006,689,1394,1018,1007,1395,1011,1396,1019,1388,696,982,199,1397,1398,1399,1400,1401,1402,1403,965,1404,199,1405,1406,199,1407,1408,1409,1410,199,1411,199,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,982,199,1433,965,1434,199,1435,1436,199,1437,1260,199,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,982,199,1458,1459,701,943],"using System;","using System.Collections.Generic;","using System.Threading;","using Microsoft.CodeAnalysis.CSharp;","using Microsoft.CodeAnalysis.CSharp.Syntax;","using NTypeForge.SourceGenerator.Models;","namespace NTypeForge.SourceGenerator"," // Transform stage (symbol-aware): detect a duck-typing site in one invocation and resolve it to"," // a value-equatable CandidateModel built entirely from primitives (strings/enums/spans). No"," // ISymbol or SyntaxNode is retained, so the incremental pipeline does not root the compilation."," // Member analysis is delegated to InterfaceRequirementsAnalyzer / SurfaceAnalyzer / MemberSignatures;"," // this type owns only the \"is this a duck site, and against what types?\" decision plus assembly"," // of the model. Returns null for invocations that are not duck-typing sites."," internal static class CandidateAnalyzer"," // A ducked argument still in symbol form, resolved per argument before model assembly."," private readonly struct DuckedArgSite"," {"," public readonly ITypeSymbol ArgType;"," public readonly ITypeSymbol UnderlyingType;"," public readonly ITypeSymbol InterfaceType;"," public readonly int EmittedIndex;"," // Set only for a ref/out/in near-miss (NTF004): the structural match is blocked because"," // the parameter is by-reference. Null on a normal (duckable) argument."," public readonly string? RefKindBlocker;"," public readonly string? BlockedParameterName;"," public DuckedArgSite(ITypeSymbol argType, ITypeSymbol underlyingType, ITypeSymbol interfaceType, int emittedIndex,"," string? refKindBlocker = null, string? blockedParameterName = null)"," ArgType = argType;"," UnderlyingType = underlyingType;"," InterfaceType = interfaceType;"," EmittedIndex = emittedIndex;"," RefKindBlocker = refKindBlocker;"," BlockedParameterName = blockedParameterName;"," }"," public static CandidateModel? GetCandidate(GeneratorSyntaxContext context, CancellationToken cancellationToken)"," var invocation = (InvocationExpressionSyntax)context.Node;"," var semanticModel = context.SemanticModel;"," var symbolInfo = semanticModel.GetSymbolInfo(invocation, cancellationToken);"," var duckCall = TryGetDuckCall(invocation, semanticModel, symbolInfo, cancellationToken);"," if (duckCall != null) return duckCall;"," // A call that bound successfully needs no duck typing; only a failed overload"," // resolution (Symbol == null, with candidates) can be rescued by generated proxies."," if (symbolInfo.Symbol != null || symbolInfo.CandidateSymbols.Length == 0) return null;"," return TryGetMethodArgumentDuck(invocation, semanticModel, symbolInfo, cancellationToken)"," ?? TryGetRefKindNearMiss(invocation, semanticModel, symbolInfo, cancellationToken);"," // Matches the top-level `NTypeForge` namespace only, so a user's unrelated"," // `Foo.NTypeForge` namespace is not mistaken for the library's."," private static bool IsTopLevelNTypeForgeNamespace(INamespaceSymbol? ns)"," => ns != null && ns.Name == \"NTypeForge\" && (ns.ContainingNamespace == null || ns.ContainingNamespace.IsGlobalNamespace);"," // The underlying type kinds NTypeForge can build a proxy around. A `ref struct` is excluded:"," // it can't be a field of the (non-ref) proxy class, can't be a type argument to IProxy, and"," // can't be cast to object - so proxying it would only emit code that fails to compile. Leaving"," // such a site alone lets the compiler's own (correct) error stand."," private static bool IsProxyableKind(ITypeSymbol type)"," => !type.IsRefLikeType &&"," (type.TypeKind == TypeKind.Class || type.TypeKind == TypeKind.Struct || type.TypeKind == TypeKind.Interface);"," private static bool IsUsableFromGeneratedTopLevelCode(ITypeSymbol type)"," switch (type)"," case IArrayTypeSymbol array:"," return IsUsableFromGeneratedTopLevelCode(array.ElementType);"," case IPointerTypeSymbol pointer:"," return IsUsableFromGeneratedTopLevelCode(pointer.PointedAtType);"," case INamedTypeSymbol named:"," foreach (var arg in named.TypeArguments)"," {"," if (!IsUsableFromGeneratedTopLevelCode(arg)) return false;"," }"," for (INamedTypeSymbol? current = named; current != null; current = current.ContainingType)"," if (!IsTypeAccessibilityUsable(current.DeclaredAccessibility)) return false;"," return true;"," default:"," // Type parameters, dynamic, etc.: nothing the generated code couldn't name."," private static bool IsTypeAccessibilityUsable(Accessibility accessibility)"," => accessibility == Accessibility.Public ||"," accessibility == Accessibility.Internal ||"," accessibility == Accessibility.ProtectedOrInternal;"," private static bool IsEffectivelyPublic(ITypeSymbol type)"," for (var current = type; current != null; current = current.ContainingType)"," if (current.DeclaredAccessibility != Accessibility.Public) return false;"," return true;"," private static ITypeSymbol GetUnderlyingType(ITypeSymbol type)"," bool IsProxyInterface(ITypeSymbol t)"," if (t is INamedTypeSymbol nt && nt.IsGenericType && nt.Name == \"IProxy\" && nt.TypeArguments.Length == 1)"," return IsTopLevelNTypeForgeNamespace(nt.ContainingNamespace);"," return false;"," if (IsProxyInterface(type))"," return ((INamedTypeSymbol)type).TypeArguments[0];"," foreach (var iface in type.AllInterfaces)"," if (IsProxyInterface(iface))"," return ((INamedTypeSymbol)iface).TypeArguments[0];"," return type;"," // An explicit `instance.Duck()` call (the member-access form is the only one the generated"," // instance extension member can intercept; see GetDuckInstanceExpression)."," private static CandidateModel? TryGetDuckCall("," InvocationExpressionSyntax invocation, SemanticModel semanticModel, SymbolInfo symbolInfo,"," CancellationToken cancellationToken)"," if (!(symbolInfo.Symbol is IMethodSymbol resolved) || resolved.Name != \"Duck\" ||"," !IsTopLevelNTypeForgeNamespace(resolved.ContainingNamespace) || resolved.TypeArguments.Length != 1)"," return null;"," var instanceExpr = GetDuckInstanceExpression(invocation, semanticModel, cancellationToken);"," if (instanceExpr == null) return null;"," var argType = semanticModel.GetTypeInfo(instanceExpr, cancellationToken).Type;"," if (argType == null) return null;"," var targetInterface = resolved.TypeArguments[0];"," var underlyingType = GetUnderlyingType(argType);"," if (targetInterface.TypeKind != TypeKind.Interface || !IsProxyableKind(underlyingType)) return null;"," if (ContainsTypeParameter(argType) || ContainsTypeParameter(underlyingType) || ContainsTypeParameter(targetInterface))"," if (!IsUsableFromGeneratedTopLevelCode(argType) ||"," !IsUsableFromGeneratedTopLevelCode(underlyingType) ||"," !IsUsableFromGeneratedTopLevelCode(targetInterface))"," // The instance already satisfies the interface (nominally or via variance), so no proxy"," // is needed: the runtime Duck fallback's `instance is T` returns it directly."," // Generating a proxy here would only add a needless wrap/box."," if (AlreadyImplements(semanticModel, argType, targetInterface)) return null;"," return BuildModel("," invocation, target: argType,"," duckedArgs: new[] { new DuckedArgSite(argType, underlyingType, targetInterface, emittedIndex: 0) },"," isStatic: false, isDuckCall: true, originalMethod: null);"," private static bool AlreadyImplements(SemanticModel semanticModel, ITypeSymbol type, ITypeSymbol interfaceType)"," // Identity or an implicit reference conversion (which covers nominal implementation AND"," // variance, e.g. ICovariant is-a ICovariant