From dce26ed1f5d831e36f78f02e307b8b772c8a8800 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 19 Sep 2026 03:59:57 +0000 Subject: [PATCH 1/3] P-037 A2.1: emit the guarded-fact sidecar from the Roslyn extractor, validated and inert MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Treatment-only step of the A2 staging (docs/notes/p037-formal-kernel.md §10.3): the extractor now writes `functions[].guarded_facts`, the raw record of what flows into each relevant call and what each eligible `if` tests, keyed by declared parameter ordinal. Neither engine reads it; the legacy `body` stays authoritative; no path under the A2.0 instrument freeze is touched, so the after-takes on M1 compare directly against the R baselines with population_commit = T. Producer (frontend/roslyn/OwnSharp.Extractor/Program.cs): - calls[]: one per call a disposable candidate local or an owned parameter flows into (argument or reduced-extension receiver); site {line, column} of the invocation plus statement_line as the join identity with the legacy ops; form statement|initializer|expression; callee/sig or null when unresolved; first_party; args bound by declared ordinal (named args resolved, extension receiver = 0, params/ref/out = opaque, unresolved callee = source position). - arg kinds (raw facts only, §10.2): var{name}, param{source_param[,negated]}, bool_const{value}, null_literal, object_creation, call_result{callee,sig}, opaque. No const-pos/id/neg and no fresh_owned are ever written. - guards[]: one per eligible `if` on a stable by-value parameter — truth on a bool, is_null/not_null on a reference or Nullable; G-V4 stability is whole-body write exposure (assignment, ++/--, ref/out, ref alias, address). Ineligible guards get no entry: absence is the fail-closed signal. - Self-check: a sidecar that violates its own vocabulary makes the run refuse to write facts at all (exit 2), so a producer defect never reaches a door. Contract (spec/ownir.schema.json, spec/OwnIR.md §5.2, §4.2): - closed $defs guardedFacts/guardedCall/guardedArg/guardedGuard/sourceSite; the sidecar is optional and additive, OWNIR_VERSION stays 0. - sourceSite is deliberately UNBOUND (type only): the doors do not read the sidecar in A2.1, and §4.2 forbids a schema narrower than the door on a coordinate the door does not check. tests/test_ownir_defensive_limits.py classifies it as the one UNBOUND entry; the instrument step that registers the sidecar at the doors moves it to BOUND. Controls: - corpus/p037-shapes: all 11 shapes re-recorded with the sidecar (body ops, params and both engines' verdicts byte-identical to before), status pending_a2 -> anchored, and a2_expect contract checks per shape that fail by name (scripts/p037_fact_shapes.py check). - tests/test_p037_sidecar.py pins the schema enums against the producer's vocabularies and the raw-fact boundary. - scripts/p037_sidecar_inertness.py (CI dogfood step): for every census shape and the samples tree, the emitted, stripped and contradictory sidecars yield identical lowered/summaries/verdicts layers on both engines, python == rust, and the control is non-vacuous (39 sidecars over 12 documents locally). Known A2.1 boundary, owed by A2.2 (honest emission for every relevant call): object-creation arguments (`new X(handle, leaveOpen: true)`) are not yet a call fact; A2.1 covers invocation expressions. Refs #304 Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01QfeUtLRm6KFRWcTGQZxQQb --- .github/workflows/ci.yml | 6 + .../call-expression-statement/expected.json | 94 +++- .../extension-receiver/expected.json | 69 ++- .../guard-bool-const-false/expected.json | 85 +++- .../guard-bool-const-true/expected.json | 85 +++- .../guard-forward-bare/expected.json | 85 +++- .../guard-forward-negated/expected.json | 87 +++- .../p037-shapes/guard-mutated/expected.json | 67 ++- .../guard-opaque-expression/expected.json | 83 +++- .../p037-shapes/guard-ref-alias/expected.json | 67 ++- .../named-arguments-reordered/expected.json | 88 +++- .../return-disposable-parameter/expected.json | 54 ++- frontend/roslyn/OwnSharp.Extractor/Program.cs | 428 +++++++++++++++++- pyproject.toml | 1 + scripts/p037_fact_shapes.py | 59 ++- scripts/p037_sidecar_inertness.py | 204 +++++++++ spec/OwnIR.md | 82 ++++ spec/ownir.schema.json | 274 ++++++++++- tests/test_ownir_defensive_limits.py | 19 +- tests/test_p037_sidecar.py | 127 ++++++ 20 files changed, 2005 insertions(+), 59 deletions(-) create mode 100755 scripts/p037_sidecar_inertness.py create mode 100644 tests/test_p037_sidecar.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 88e7c5b8..89b6db21 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -3039,6 +3039,12 @@ jobs: # re-hashed and removed again. No baseline is taken here. python scripts/p037_evidence.py artifacts python scripts/p037_evidence.py population --source repo --materialize --cleanup + # A2.1: the guarded-fact sidecar is validated and INERT. Every census + # shape and the samples compilation go through both engines three + # times (as emitted, stripped, deliberately contradictory) and the + # lowered/summaries/verdicts layers must not move. Needs the + # own-shadow-engine the artifacts step just built. + python scripts/p037_sidecar_inertness.py # The Windows launcher is a separate implementation, not a wrapper around # the shell one, so the Windows leg has to go through it to mean anything. - name: Own.NET's own tree, through own-check.ps1 on the Rust core diff --git a/corpus/p037-shapes/call-expression-statement/expected.json b/corpus/p037-shapes/call-expression-statement/expected.json index 22245c56..10638be6 100644 --- a/corpus/p037-shapes/call-expression-statement/expected.json +++ b/corpus/p037-shapes/call-expression-statement/expected.json @@ -1,9 +1,47 @@ { "schema": "p037-fact-shape/1", "shape": "call-expression-statement", - "status": "pending_a2", + "status": "anchored", "why": "The heart of the a2 gap. The C# lowering emits a `call` op in exactly ONE place and only for `var x = Foo(...)` — a call whose RESULT binds to a local. `Inner(r, true);` as a STATEMENT produces no `call` node, which the recorded facts show: `Caller`'s body is `acquire:r`, `release:r` — the fabricated release — and no call at all. So F3 cannot be carried through the existing summary layer today: there is no node for a guarded summary to specialise.", "a2_contract": "a2 emits a real `call` op for relevant first-party statement-level calls. This is also where a2's zero-semantic-cut risk lives, and it must be measured rather than hoped: a real `call` op is ALREADY semantically active and MOS reads it, so emitting one here can move an existing summary long before the guarded kernel is anywhere near. A verdict that happens to stay the same is not a pass — an unintended MOS collapsed-view change means a2 began the semantic cut early, and the answer is to isolate it or restage, never to note that the tests are green.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeStatementCall.Caller", + "call": { + "site": { + "line": 26 + }, + "form": "statement", + "callee": "ShapeStatementCall.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + }, + { + "function": "ShapeStatementCall.Inner", + "guard": { + "site": { + "line": 17 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeStatementCall.Inner": { @@ -16,18 +54,66 @@ "body": [ "if:None@17", "then:release:s@19" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 17, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeStatementCall.Caller": { "params": null, "body": [ "acquire:r@25", "release:r@26" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 26, + "column": 9 + }, + "statement_line": 26, + "form": "statement", + "callee": "ShapeStatementCall.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/extension-receiver/expected.json b/corpus/p037-shapes/extension-receiver/expected.json index 51bfb639..1db2cf20 100644 --- a/corpus/p037-shapes/extension-receiver/expected.json +++ b/corpus/p037-shapes/extension-receiver/expected.json @@ -1,9 +1,37 @@ { "schema": "p037-fact-shape/1", "shape": "extension-receiver", - "status": "pending_a2", + "status": "anchored", "why": "A reduced extension method. Roslyn's reduced symbol drops `this` from Parameters while the summary lives on the UNREDUCED declaration, where the receiver is parameter 0.\n\nTwo things measured here, and the second was a surprise. (1) `CallReleasesReceiver` — the `ConsumesParam` consumer that handles this shape — is reached ONLY from two sites gated on `ThisFieldName(...)`: it is part of the FIELD disposal detector and never runs on a local. (2) Consequently `var s = ...; s.WaitForDispose(5);` is charged OWN001 even when the extension disposes its receiver UNCONDITIONALLY — verified with an unguarded probe, so it is not the guard doing it. That is a pre-existing false positive of exactly the family P-037 addresses (a first-party callee that releases, unrecognised), arriving through the RECEIVER rather than the argument. It is not A1's to fix and is recorded here so it is not mistaken for something A1 caused.", "a2_contract": "a2 synthesises the receiver binding against the UNREDUCED declaration: receiver -> declared parameter 0, `timeout` -> declared parameter 1. Without it `CallReleasesReceiver` can never be honestly retired — the guarded summaries would be complete except for one old tunnel under the fence, on the field path where nobody is looking.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeExtensionReceiver.Caller", + "call": { + "site": { + "line": 23 + }, + "callee": "ShapeExtensionReceiver.WaitForDispose", + "sig": "System.IO.Stream,System.Int32", + "args": [ + { + "param": 0, + "kind": "var", + "name": "s" + }, + { + "param": 1, + "kind": "opaque" + } + ] + } + }, + { + "function": "ShapeExtensionReceiver.WaitForDispose", + "guarded_facts": "absent" + } + ], "measured_at": "464308b", "facts": { "ShapeExtensionReceiver.WaitForDispose": { @@ -16,14 +44,43 @@ "body": [ "if:None@14", "then:release:self@16" - ] + ], + "guarded_facts": null }, "ShapeExtensionReceiver.Caller": { "params": null, "body": [ "acquire:s@22", "use:s@23" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 23, + "column": 9 + }, + "statement_line": 23, + "form": "statement", + "callee": "ShapeExtensionReceiver.WaitForDispose", + "sig": "System.IO.Stream,System.Int32", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "s" + }, + { + "param": 1, + "kind": "opaque" + } + ] + } + ], + "guards": [] + } } }, "verdict": { @@ -33,5 +90,9 @@ "python": [ "OWN001:warning@22" ] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-bool-const-false/expected.json b/corpus/p037-shapes/guard-bool-const-false/expected.json index 9ee67cca..1874469e 100644 --- a/corpus/p037-shapes/guard-bool-const-false/expected.json +++ b/corpus/p037-shapes/guard-bool-const-false/expected.json @@ -1,9 +1,38 @@ { "schema": "p037-fact-shape/1", "shape": "guard-bool-const-false", - "status": "pending_a2", + "status": "anchored", "why": "The same call with `false`. Present so the two constants are distinguishable in the facts: a single `is a constant` bit would collapse the exact distinction cell selection turns on, and would do it invisibly.", "a2_contract": "{\"param\":1,\"kind\":\"bool_const\",\"value\":false}; Rust derives `const-neg`.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeConstFalse.Caller", + "call": { + "callee": "ShapeConstFalse.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": false + } + ] + } + }, + { + "function": "ShapeConstFalse.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeConstFalse.Inner": { @@ -16,18 +45,66 @@ "body": [ "if:None@10", "then:release:s@12" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 10, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeConstFalse.Caller": { "params": null, "body": [ "acquire:r@18", "release:r@19" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 19, + "column": 9 + }, + "statement_line": 19, + "form": "statement", + "callee": "ShapeConstFalse.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": false + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-bool-const-true/expected.json b/corpus/p037-shapes/guard-bool-const-true/expected.json index 4ac62522..410dc516 100644 --- a/corpus/p037-shapes/guard-bool-const-true/expected.json +++ b/corpus/p037-shapes/guard-bool-const-true/expected.json @@ -1,9 +1,38 @@ { "schema": "p037-fact-shape/1", "shape": "guard-bool-const-true", - "status": "pending_a2", + "status": "anchored", "why": "`Inner(r, true)`: the constant that decides the callee's branch. Today it reaches the facts as nothing at all — the statement-level call emits no `call` op, and the fabricated `release` from ConsumesParam stands in its place.", "a2_contract": "{\"param\":1,\"kind\":\"bool_const\",\"value\":true}. The frontend never writes `const-pos`: that is an interpretation relative to the callee's ELECTED guard and belongs to Rust.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeConstTrue.Caller", + "call": { + "callee": "ShapeConstTrue.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + }, + { + "function": "ShapeConstTrue.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeConstTrue.Inner": { @@ -16,18 +45,66 @@ "body": [ "if:None@11", "then:release:s@13" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 11, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeConstTrue.Caller": { "params": null, "body": [ "acquire:r@19", "release:r@20" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 20, + "column": 9 + }, + "statement_line": 20, + "form": "statement", + "callee": "ShapeConstTrue.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-forward-bare/expected.json b/corpus/p037-shapes/guard-forward-bare/expected.json index aaf9214c..b1f3d694 100644 --- a/corpus/p037-shapes/guard-forward-bare/expected.json +++ b/corpus/p037-shapes/guard-forward-bare/expected.json @@ -1,9 +1,38 @@ { "schema": "p037-fact-shape/1", "shape": "guard-forward-bare", - "status": "pending_a2", + "status": "anchored", "why": "A wrapper forwarding its own flag unchanged. Today `Outer`'s body shows a fabricated `release` where the forward belongs, so the wrapper enters the summary layer as an unconditional consumer — the may-as-must flattening, now visible INSIDE the summaries rather than only at the call site.", "a2_contract": "{\"param\":1,\"kind\":\"param\",\"source_param\":1}; Rust reads the `id` edge.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeForwardBare.Outer", + "call": { + "callee": "ShapeForwardBare.Inner", + "args": [ + { + "param": 0, + "kind": "param", + "source_param": 0 + }, + { + "param": 1, + "kind": "param", + "source_param": 1 + } + ] + } + }, + { + "function": "ShapeForwardBare.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeForwardBare.Inner": { @@ -16,7 +45,22 @@ "body": [ "if:None@9", "then:release:s@11" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 9, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeForwardBare.Outer": { "params": [ @@ -27,11 +71,44 @@ ], "body": [ "release:s@17" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 17, + "column": 9 + }, + "statement_line": 17, + "form": "statement", + "callee": "ShapeForwardBare.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "param", + "source_param": 0 + }, + { + "param": 1, + "kind": "param", + "source_param": 1 + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-forward-negated/expected.json b/corpus/p037-shapes/guard-forward-negated/expected.json index 67595f1f..9602cff9 100644 --- a/corpus/p037-shapes/guard-forward-negated/expected.json +++ b/corpus/p037-shapes/guard-forward-negated/expected.json @@ -1,9 +1,39 @@ { "schema": "p037-fact-shape/1", "shape": "guard-forward-negated", - "status": "pending_a2", + "status": "anchored", "why": "The wrapper negates the flag: `Inner(s, !stop)`. The cells must swap, and the swap has to be derivable from the facts rather than guessed.", "a2_contract": "{\"param\":1,\"kind\":\"param\",\"source_param\":1,\"negated\":true}; Rust reads the `neg` edge.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeForwardNegated.Outer", + "call": { + "callee": "ShapeForwardNegated.Inner", + "args": [ + { + "param": 0, + "kind": "param", + "source_param": 0 + }, + { + "param": 1, + "kind": "param", + "source_param": 1, + "negated": true + } + ] + } + }, + { + "function": "ShapeForwardNegated.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeForwardNegated.Inner": { @@ -16,7 +46,22 @@ "body": [ "if:None@9", "then:release:s@11" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 9, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeForwardNegated.Outer": { "params": [ @@ -27,11 +72,45 @@ ], "body": [ "release:s@17" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 17, + "column": 9 + }, + "statement_line": 17, + "form": "statement", + "callee": "ShapeForwardNegated.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "param", + "source_param": 0 + }, + { + "param": 1, + "kind": "param", + "source_param": 1, + "negated": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-mutated/expected.json b/corpus/p037-shapes/guard-mutated/expected.json index 3e5f14da..686d863b 100644 --- a/corpus/p037-shapes/guard-mutated/expected.json +++ b/corpus/p037-shapes/guard-mutated/expected.json @@ -1,9 +1,34 @@ { "schema": "p037-fact-shape/1", "shape": "guard-mutated", - "status": "pending_a2", + "status": "anchored", "why": "The guard parameter is WRITTEN before the branch reads it, so its entry value no longer decides anything. Recorded verdict today: a false OWN003 — the same defect the gv4-control-mutated-guard control carries, reproduced here in minimal form and independently of it.", "a2_contract": "G-V4 fails closed: NOT eligible, therefore NO guard metadata on the `if`. Absence is the signal. The frontend must not emit `\"stable\": false` — an old producer, an unstable parameter, an unsupported predicate and unknown syntax all have to degrade the same way, and one of them will always be `a producer that predates this field`.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeMutatedGuard.Inner", + "guarded_facts": "absent" + }, + { + "function": "ShapeMutatedGuard.Caller", + "call": { + "callee": "ShapeMutatedGuard.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + } + ], "measured_at": "464308b", "facts": { "ShapeMutatedGuard.Inner": { @@ -16,7 +41,8 @@ "body": [ "if:None@13", "then:release:p@15" - ] + ], + "guarded_facts": null }, "ShapeMutatedGuard.Caller": { "params": null, @@ -24,7 +50,36 @@ "acquire:r@21", "release:r@22", "release:r@23" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 22, + "column": 9 + }, + "statement_line": 22, + "form": "statement", + "callee": "ShapeMutatedGuard.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { @@ -34,5 +89,9 @@ "python": [ "OWN003:warning@21" ] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-opaque-expression/expected.json b/corpus/p037-shapes/guard-opaque-expression/expected.json index aafe0f2b..df249a49 100644 --- a/corpus/p037-shapes/guard-opaque-expression/expected.json +++ b/corpus/p037-shapes/guard-opaque-expression/expected.json @@ -1,9 +1,37 @@ { "schema": "p037-fact-shape/1", "shape": "guard-opaque-expression", - "status": "pending_a2", + "status": "anchored", "why": "An arbitrary expression in the guard argument position. The case exists to pin what the frontend must NOT do.", "a2_contract": "{\"param\":1,\"kind\":\"opaque\"} and nothing else. Specifically NOT `\"expr\": \"n > 0 && !flag\"` for something downstream to parse later: humanity already has one C# front end and does not need a second one growing quietly inside a summary engine.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeOpaqueArg.Caller", + "call": { + "callee": "ShapeOpaqueArg.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "opaque" + } + ] + } + }, + { + "function": "ShapeOpaqueArg.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeOpaqueArg.Inner": { @@ -16,18 +44,65 @@ "body": [ "if:None@11", "then:release:s@13" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 11, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeOpaqueArg.Caller": { "params": null, "body": [ "acquire:r@19", "release:r@20" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 20, + "column": 9 + }, + "statement_line": 20, + "form": "statement", + "callee": "ShapeOpaqueArg.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "opaque" + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/guard-ref-alias/expected.json b/corpus/p037-shapes/guard-ref-alias/expected.json index 2ffc7646..3cb19ced 100644 --- a/corpus/p037-shapes/guard-ref-alias/expected.json +++ b/corpus/p037-shapes/guard-ref-alias/expected.json @@ -1,9 +1,34 @@ { "schema": "p037-fact-shape/1", "shape": "guard-ref-alias", - "status": "pending_a2", + "status": "anchored", "why": "The guard is handed to a `ref` parameter before the branch reads it, so a callee may have changed it. Same G-V4 answer as a direct write, reached by a different route; recorded verdict today is the same false OWN003.", "a2_contract": "Not eligible, no guard metadata. Identical treatment to a direct write.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeRefAliasGuard.Inner", + "guarded_facts": "absent" + }, + { + "function": "ShapeRefAliasGuard.Caller", + "call": { + "callee": "ShapeRefAliasGuard.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + } + ], "measured_at": "464308b", "facts": { "ShapeRefAliasGuard.Inner": { @@ -16,7 +41,8 @@ "body": [ "if:None@16", "then:release:p@18" - ] + ], + "guarded_facts": null }, "ShapeRefAliasGuard.Caller": { "params": null, @@ -24,7 +50,36 @@ "acquire:r@24", "release:r@25", "release:r@26" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 25, + "column": 9 + }, + "statement_line": 25, + "form": "statement", + "callee": "ShapeRefAliasGuard.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "r" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { @@ -34,5 +89,9 @@ "python": [ "OWN003:warning@24" ] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/named-arguments-reordered/expected.json b/corpus/p037-shapes/named-arguments-reordered/expected.json index 4ef089f2..f281304e 100644 --- a/corpus/p037-shapes/named-arguments-reordered/expected.json +++ b/corpus/p037-shapes/named-arguments-reordered/expected.json @@ -1,9 +1,41 @@ { "schema": "p037-fact-shape/1", "shape": "named-arguments-reordered", - "status": "pending_a2", + "status": "anchored", "why": "Today `Inner(flag: true, resource: s)` produces no `call` op at all (statement-level calls emit none), and even where a call IS emitted its `args` drops every named argument (`a.NameColon is null`). The comment there is right that keeping a named argument in SOURCE order would mis-align a positional mapping. The cure is to resolve it, not to discard it.", "a2_contract": "a2 emits a `call` op here whose `arg_bindings` resolve BY DECLARED PARAMETER INDEX, so this reordered call and a positional `Inner(s, true)` produce the same bindings: param 0 -> {kind: var, name: s}, param 1 -> {kind: bool_const, value: true}. Source order is Roslyn's problem and stops being anyone else's. The legacy `args: string[]` field keeps its current contents and meaning — additive only, so the Python rollback reads an unchanged document.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeNamedArgs.Caller", + "call": { + "site": { + "line": 21 + }, + "callee": "ShapeNamedArgs.Inner", + "args": [ + { + "param": 0, + "kind": "var", + "name": "s" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + }, + { + "function": "ShapeNamedArgs.Inner", + "guard": { + "param": 1, + "predicate": "truth", + "negated": true + } + } + ], "measured_at": "464308b", "facts": { "ShapeNamedArgs.Inner": { @@ -16,18 +48,66 @@ "body": [ "if:None@12", "then:release:resource@14" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [], + "guards": [ + { + "site": { + "line": 12, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": true + } + ] + } }, "ShapeNamedArgs.Caller": { "params": null, "body": [ "acquire:s@20", "release:s@21" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 21, + "column": 9 + }, + "statement_line": 21, + "form": "statement", + "callee": "ShapeNamedArgs.Inner", + "sig": "System.IO.Stream,System.Boolean", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "s" + }, + { + "param": 1, + "kind": "bool_const", + "value": true + } + ] + } + ], + "guards": [] + } } }, "verdict": { "rust": [], "python": [] - } + }, + "status_history": [ + "pending_a2 (recorded at 464308b)", + "anchored (A2.1 sidecar)" + ] } diff --git a/corpus/p037-shapes/return-disposable-parameter/expected.json b/corpus/p037-shapes/return-disposable-parameter/expected.json index 089658ed..af934fea 100644 --- a/corpus/p037-shapes/return-disposable-parameter/expected.json +++ b/corpus/p037-shapes/return-disposable-parameter/expected.json @@ -3,6 +3,31 @@ "shape": "return-disposable-parameter", "status": "anchored", "why": "A1.1-a1 REGRESSION ANCHOR. Putting owned parameters into the lowering set made `return s` lower as a fresh-factory return, and the core read a fresh return of something it never saw acquired as an escaping borrow: [OWN004] 'parg_N' is a borrow and cannot be returned. Six CI jobs, and the 137-file verdict corpus never saw it, because no corpus case returns its own disposable parameter. The recorded facts pin the fix: Echo's `return` carries var=None. What the return really is, is an ALIAS of the parameter; OwnIR reserves `aliasOf`/`aliased` and has never emitted them, so the frontend claims no owned return rather than asserting a false kind. If this record ever shows `return:s`, the alias gap has been filled by accident instead of on purpose.", + "a2_landed": "A2.1 landed the guarded-fact SIDECAR (`guarded_facts`, spec/OwnIR.md §5.2), not a body op: the legacy `body` stays authoritative through A2 and C+ canonicalizes the two views (docs/notes/p037-formal-kernel.md §10.3/§10.5). The `a2_expect` entries are this shape's contract, checked by name; `facts` pins the whole record byte for byte.", + "a2_expect": [ + { + "function": "ShapeReturnParam.Echo", + "guarded_facts": "absent" + }, + { + "function": "ShapeReturnParam.Use", + "call": { + "site": { + "line": 24 + }, + "form": "initializer", + "callee": "ShapeReturnParam.Echo", + "sig": "System.IO.Stream", + "args": [ + { + "param": 0, + "kind": "var", + "name": "owned" + } + ] + } + } + ], "measured_at": "464308b", "facts": { "ShapeReturnParam.Echo": { @@ -15,14 +40,39 @@ "body": [ "use:s@18", "return:None@18" - ] + ], + "guarded_facts": null }, "ShapeReturnParam.Use": { "params": null, "body": [ "call:ShapeReturnParam.Echo@24[args=[]]", "release:same@25" - ] + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 24, + "column": 20 + }, + "statement_line": 24, + "form": "initializer", + "callee": "ShapeReturnParam.Echo", + "sig": "System.IO.Stream", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "var", + "name": "owned" + } + ] + } + ], + "guards": [] + } } }, "verdict": { diff --git a/frontend/roslyn/OwnSharp.Extractor/Program.cs b/frontend/roslyn/OwnSharp.Extractor/Program.cs index 33bd542e..0e3d831f 100644 --- a/frontend/roslyn/OwnSharp.Extractor/Program.cs +++ b/frontend/roslyn/OwnSharp.Extractor/Program.cs @@ -2850,6 +2850,381 @@ static string CanonicalSig(IMethodSymbol m) => _ => t.ToDisplayString().Replace("global::", ""), // dynamic / error types }; +// ---- P-037 A2.1 (#304): the guarded-fact sidecar --------------------------------------------- +// +// `functions[].guarded_facts` is the frontend's RAW record of what flows into each relevant call +// and what each `if` tests — the input the guarded summary engine (P-037) reads once phase B +// wires it. In A2 it is VALIDATED AND INERT: neither engine reads it, the legacy `body` stays +// authoritative, and a run's MOS documents and verdicts must not move when it appears +// (docs/notes/p037-formal-kernel.md §10.3; the A2 baselines under docs/evidence are the +// witness, the shape census under corpus/p037-shapes pins the per-shape facts). +// +// Two rules govern every field, both from the §10.2 freeze: +// +// * Roslyn reports SOURCE facts, never P-037 interpretations. `bool_const true` is a fact; +// `const-pos` is an interpretation relative to the callee's ELECTED guard and belongs to +// the engine. `param` names the caller's own parameter by declared ordinal; whether that +// is an `id` or a `neg` edge is the engine's reading. No `fresh_owned` is ever written: a +// call result is `call_result{callee,sig}` and freshness is a summary conclusion. +// * Absence is the fail-closed signal. A guard that is not eligible — G-V1: a by-value +// boolean parameter, or the null-ness of a by-value reference parameter (the self-null +// split included); G-V4: the parameter is never assigned, incremented, taken by `ref`, +// or passed by ref/out anywhere in the body — gets NO entry, never `stable: false`, so an +// old producer, an unstable parameter, an unsupported predicate and unknown syntax all +// degrade the same way. The same stability rule decides whether an ARGUMENT that names a +// parameter is a `param` fact or `opaque`. +// +// A call is RELEVANT when a disposable local (any candidate, escaped or not: the legacy +// escape-by-argument is the approximation a summary will refine) or an owned parameter of +// this method flows into it, as an argument or as the receiver of a reduced extension +// method (declared parameter 0). +// Arguments bind BY DECLARED PARAMETER ORDINAL: a named argument resolves to its parameter, +// a reduced extension's receiver to ordinal 0, anything bound to a `params` array collapses +// to one `opaque` fact for that slot, an omitted optional argument has no fact, a `ref`/`out` +// argument is `opaque` (the callee may write it). For an unresolved callee (`callee: null`) +// the ordinal is the SOURCE position — there is no declaration to bind against, and saying +// so beats guessing. Calls inside lambdas and local functions are not this method's calls. +// +// The call-site identity is the invocation expression's own start coordinate plus the +// enclosing statement's line (`statement_line`, the coordinate the legacy body ops carry), +// so the legacy view and this one can be joined until C+ canonicalizes them (§10.5). +// +// Self-check: every record is validated against this vocabulary as it is built, and one +// malformed record makes the producer refuse to write facts at all (exit 2) — fail-loud at +// the source, before either door is asked to notice. +static ExpressionSyntax? StripParens(ExpressionSyntax? e) +{ + while (e is ParenthesizedExpressionSyntax pe) + e = pe.Expression; + return e; +} + +static bool IsNullLiteral(ExpressionSyntax? e) => + StripParens(e) is LiteralExpressionSyntax l && l.IsKind(SyntaxKind.NullLiteralExpression); + +// G-V4, whole-body write exposure (deliberately coarser than flow-sensitive, per P-037 §2): +// a parameter is STABLE when nothing in the method body can change the value it entered +// with — no assignment (plain, compound, or deconstructing), no ++/--, no `ref`/`out` +// argument, no `ref` alias, no address taken. A write inside a lambda counts: the closure +// may run before the read. +static bool ParameterIsStable(IParameterSymbol p, SyntaxNode body, SemanticModel model) +{ + bool Refers(ExpressionSyntax? e) => + StripParens(e) is IdentifierNameSyntax id + && SymbolEqualityComparer.Default.Equals(model.GetSymbolInfo(id).Symbol, p); + foreach (var n in body.DescendantNodes()) + { + switch (n) + { + case AssignmentExpressionSyntax a: + if (Refers(a.Left)) + return false; + if (a.Left is TupleExpressionSyntax + && a.Left.DescendantNodes().OfType().Any(id => Refers(id))) + return false; + break; + case PrefixUnaryExpressionSyntax u when u.IsKind(SyntaxKind.PreIncrementExpression) + || u.IsKind(SyntaxKind.PreDecrementExpression) + || u.IsKind(SyntaxKind.AddressOfExpression): + if (Refers(u.Operand)) + return false; + break; + case PostfixUnaryExpressionSyntax u when u.IsKind(SyntaxKind.PostIncrementExpression) + || u.IsKind(SyntaxKind.PostDecrementExpression): + if (Refers(u.Operand)) + return false; + break; + case ArgumentSyntax arg when arg.RefKindKeyword.IsKind(SyntaxKind.RefKeyword) + || arg.RefKindKeyword.IsKind(SyntaxKind.OutKeyword): + if (Refers(arg.Expression)) + return false; + break; + case RefExpressionSyntax r: + if (Refers(r.Expression)) + return false; + break; + } + } + return true; +} + +static object? BuildGuardedFacts(BaseMethodDeclarationSyntax method, BlockSyntax mbody, + HashSet handles, HashSet ownedParamNames, + SemanticModel model, string where) +{ + var self = model.GetDeclaredSymbol(method) as IMethodSymbol; + var stability = new Dictionary(SymbolEqualityComparer.Default); + + IParameterSymbol? OwnParam(ExpressionSyntax? e) => + StripParens(e) is IdentifierNameSyntax id + && model.GetSymbolInfo(id).Symbol is IParameterSymbol p + && self is not null + && SymbolEqualityComparer.Default.Equals(p.ContainingSymbol, self) + && p.RefKind == RefKind.None + ? p : null; + + bool Stable(IParameterSymbol p) + { + if (!stability.TryGetValue(p, out var known)) + stability[p] = known = ParameterIsStable(p, mbody, model); + return known; + } + + // One argument expression -> one raw fact, plus whether a HANDLE of this method flowed. + (Dictionary fact, bool handle) ArgFact(ExpressionSyntax? raw) + { + var e = StripParens(raw); + switch (e) + { + case LiteralExpressionSyntax lit when lit.IsKind(SyntaxKind.TrueLiteralExpression): + return (new() { ["kind"] = "bool_const", ["value"] = true }, false); + case LiteralExpressionSyntax lit when lit.IsKind(SyntaxKind.FalseLiteralExpression): + return (new() { ["kind"] = "bool_const", ["value"] = false }, false); + case LiteralExpressionSyntax lit when lit.IsKind(SyntaxKind.NullLiteralExpression): + return (new() { ["kind"] = "null_literal" }, false); + case ObjectCreationExpressionSyntax or ImplicitObjectCreationExpressionSyntax: + return (new() { ["kind"] = "object_creation" }, false); + case PrefixUnaryExpressionSyntax u when u.IsKind(SyntaxKind.LogicalNotExpression): + if (OwnParam(u.Operand) is { } np + && np.Type.SpecialType == SpecialType.System_Boolean && Stable(np)) + return (new() { ["kind"] = "param", ["source_param"] = np.Ordinal, + ["negated"] = true }, false); + return (new() { ["kind"] = "opaque" }, false); + case IdentifierNameSyntax id: + if (OwnParam(id) is { } sp) + { + if (!Stable(sp)) + return (new() { ["kind"] = "opaque" }, false); + return (new() { ["kind"] = "param", ["source_param"] = sp.Ordinal }, + ownedParamNames.Contains(sp.Name)); + } + if (model.GetSymbolInfo(id).Symbol is ILocalSymbol + && handles.Contains(id.Identifier.Text)) + return (new() { ["kind"] = "var", ["name"] = id.Identifier.Text }, true); + return (new() { ["kind"] = "opaque" }, false); + case InvocationExpressionSyntax cinv: + if (model.GetSymbolInfo(cinv).Symbol is IMethodSymbol cm + && cm.MethodKind != MethodKind.DelegateInvoke) + return (new() { ["kind"] = "call_result", + ["callee"] = $"{cm.ContainingType.ToDisplayString()}.{cm.Name}", + ["sig"] = CanonicalSig(cm) }, false); + return (new() { ["kind"] = "opaque" }, false); + default: + return (new() { ["kind"] = "opaque" }, false); + } + } + + // Lambdas and local functions are not this method's calls (the legacy pass treats a + // capture as an escape for the same reason), so their subtrees are not descended. + static bool InThisMethod(SyntaxNode n) => + n is not (AnonymousFunctionExpressionSyntax or LocalFunctionStatementSyntax); + + var calls = new List>(); + foreach (var inv in mbody.DescendantNodes(InThisMethod).OfType()) + { + if (inv.Expression is IdentifierNameSyntax { Identifier.Text: "nameof" } + && model.GetSymbolInfo(inv).Symbol is null) + continue; // `nameof(s)` is not a call + var sym = model.GetSymbolInfo(inv).Symbol as IMethodSymbol; + var decl = sym is null ? null : (sym.ReducedFrom ?? sym); + var reduced = sym?.ReducedFrom is not null; + var facts = new SortedDictionary>(); + var relevant = false; + + void Bind(int ordinal, Dictionary fact, bool handle) + { + // Two arguments on one ordinal can only be a `params` expansion: one opaque slot. + if (facts.ContainsKey(ordinal)) + fact = new() { ["kind"] = "opaque" }; + facts[ordinal] = fact; + relevant |= handle; + } + + if (reduced && inv.Expression is MemberAccessExpressionSyntax ma) + { + var (rf, rh) = ArgFact(ma.Expression); + Bind(0, rf, rh); + } + var args = inv.ArgumentList.Arguments; + for (var i = 0; i < args.Count; i++) + { + int ordinal; + IParameterSymbol? bound = null; + if (decl is not null) + { + if (args[i].NameColon is { } nc) + bound = decl.Parameters.FirstOrDefault(q => q.Name == nc.Name.Identifier.Text); + else + { + var pos = i + (reduced ? 1 : 0); + bound = pos < decl.Parameters.Length + ? decl.Parameters[pos] + : decl.Parameters.LastOrDefault(q => q.IsParams); + } + if (bound is null) + continue; // nothing to bind against (a name Roslyn could not resolve) + ordinal = bound.Ordinal; + } + else + ordinal = i; // unresolved callee: source position, and the record says so + var refOrOut = args[i].RefKindKeyword.IsKind(SyntaxKind.RefKeyword) + || args[i].RefKindKeyword.IsKind(SyntaxKind.OutKeyword); + if (refOrOut || bound is { IsParams: true }) + Bind(ordinal, new() { ["kind"] = "opaque" }, false); + else + { + var (af, ah) = ArgFact(args[i].Expression); + Bind(ordinal, af, ah); + } + } + if (!relevant) + continue; + + var target = inv.Parent is AwaitExpressionSyntax aw ? (SyntaxNode)aw : inv; + var form = target.Parent switch + { + ExpressionStatementSyntax => "statement", + EqualsValueClauseSyntax => "initializer", + _ => "expression", + }; + var pos0 = PosOf(inv); + var statement = inv.FirstAncestorOrSelf(); + var record = new Dictionary + { + ["site"] = new Dictionary { ["line"] = pos0.Line, ["column"] = pos0.Column }, + ["statement_line"] = statement is null ? pos0.Line : LineOf(statement), + ["form"] = form, + ["callee"] = sym is null ? null : $"{sym.ContainingType.ToDisplayString()}.{sym.Name}", + ["sig"] = sym is null ? null : CanonicalSig(sym), + ["first_party"] = decl is not null && decl.DeclaringSyntaxReferences.Length > 0, + ["args"] = facts.Select(kv => + { + var f = new Dictionary { ["param"] = kv.Key }; + foreach (var (k, v) in kv.Value) + f[k] = v; + return f; + }).ToList(), + }; + calls.Add(record); + } + + var guards = new List>(); + foreach (var ifs in mbody.DescendantNodes(InThisMethod).OfType()) + { + var cond = StripParens(ifs.Condition); + IParameterSymbol? gp = null; + string? predicate = null; + var negated = false; + switch (cond) + { + case IdentifierNameSyntax: + gp = OwnParam(cond); + predicate = "truth"; + break; + case PrefixUnaryExpressionSyntax u when u.IsKind(SyntaxKind.LogicalNotExpression): + gp = OwnParam(u.Operand); + predicate = "truth"; + negated = true; + break; + case BinaryExpressionSyntax b when b.IsKind(SyntaxKind.EqualsExpression) + || b.IsKind(SyntaxKind.NotEqualsExpression): + var side = IsNullLiteral(b.Right) ? b.Left : IsNullLiteral(b.Left) ? b.Right : null; + gp = OwnParam(side); + predicate = b.IsKind(SyntaxKind.EqualsExpression) ? "is_null" : "not_null"; + break; + case IsPatternExpressionSyntax ip: + gp = OwnParam(ip.Expression); + predicate = ip.Pattern switch + { + ConstantPatternSyntax cp when IsNullLiteral(cp.Expression) => "is_null", + UnaryPatternSyntax { Pattern: ConstantPatternSyntax ncp } up + when up.IsKind(SyntaxKind.NotPattern) && IsNullLiteral(ncp.Expression) => "not_null", + _ => null, + }; + break; + } + if (gp is null || predicate is null) + continue; + var typeFits = predicate == "truth" + ? gp.Type.SpecialType == SpecialType.System_Boolean + : gp.Type.IsReferenceType + || gp.Type is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T }; + if (!typeFits || !Stable(gp)) + continue; // not eligible: no entry, by design + var gpos = PosOf(ifs); + guards.Add(new Dictionary + { + ["site"] = new Dictionary { ["line"] = gpos.Line, ["column"] = gpos.Column }, + ["param"] = gp.Ordinal, + ["predicate"] = predicate, + ["negated"] = negated, + }); + } + + if (calls.Count == 0 && guards.Count == 0) + return null; + ValidateGuardedFacts(calls, guards, where); + return new Dictionary { ["version"] = 1, ["calls"] = calls, ["guards"] = guards }; +} + +// The producer's own conformance check of one sidecar against the vocabulary above. Records a +// message per violation; the run refuses to write facts if any was recorded. +static void ValidateGuardedFacts(List> calls, + List> guards, string where) +{ + void Fail(string what) => GuardedFactsViolations.Add($"{where}: {what}"); + static bool Coord(object? site) => + site is Dictionary d + && d.TryGetValue("line", out var l) && l is int li && li >= 1 + && d.TryGetValue("column", out var c) && c is int ci && ci >= 1; + foreach (var call in calls) + { + if (!Coord(call.GetValueOrDefault("site"))) + Fail("call site without a 1-based line/column"); + if (call.GetValueOrDefault("form") is not string form || !CallForms.Contains(form)) + Fail("call with an unknown form"); + if (call.GetValueOrDefault("callee") is not (null or string)) + Fail("call with a non-string callee"); + if (call.GetValueOrDefault("args") is not List> args || args.Count == 0) + { + Fail("call without arguments (a relevant call binds at least one handle)"); + continue; + } + var last = -1; + foreach (var arg in args) + { + if (arg.GetValueOrDefault("param") is not int ordinal || ordinal <= last) + Fail("call arguments are not bound to strictly ascending declared ordinals"); + else + last = ordinal; + var kind = arg.GetValueOrDefault("kind") as string; + if (kind is null || !GuardedArgKinds.Contains(kind)) + Fail($"argument of unknown kind {kind ?? ""}"); + else if (kind == "bool_const" && arg.GetValueOrDefault("value") is not bool) + Fail("bool_const without a boolean value"); + else if (kind == "param" && arg.GetValueOrDefault("source_param") is not int) + Fail("param fact without a source_param ordinal"); + else if (kind == "var" && arg.GetValueOrDefault("name") is not string { Length: > 0 }) + Fail("var fact without a name"); + else if (kind == "call_result" + && (arg.GetValueOrDefault("callee") is not string { Length: > 0 } + || arg.GetValueOrDefault("sig") is not string)) + Fail("call_result without callee/sig"); + } + } + foreach (var guard in guards) + { + if (!Coord(guard.GetValueOrDefault("site"))) + Fail("guard site without a 1-based line/column"); + if (guard.GetValueOrDefault("param") is not int gp || gp < 0) + Fail("guard without a parameter ordinal"); + if (guard.GetValueOrDefault("predicate") is not string pred || !GuardPredicates.Contains(pred)) + Fail("guard with an unknown predicate"); + if (guard.GetValueOrDefault("negated") is not bool) + Fail("guard without a negated flag"); + } +} + // P-005 D5.4 (T4 wrap/adopt): the set of OWNING fields a first-party type disposes // UNCONDITIONALLY in its `Dispose()` — i.e. a `_f.Dispose()` / `_f?.Dispose()` / // `this._f.Dispose()` that is a TOP-LEVEL statement of the Dispose body (not nested in an @@ -6720,14 +7095,26 @@ or ImplicitObjectCreationExpressionSyntax } init var fsig = model.GetDeclaredSymbol(method) is IMethodSymbol sigsym ? CanonicalSig(sigsym) : null; - flowFunctions.Add( - (fsig, ownedParams.Count > 0) switch - { - (not null, true) => new { name = fname, file, sig = fsig, @params = ownedParams, body = fbody }, - (not null, false) => (object)new { name = fname, file, sig = fsig, body = fbody }, - (null, true) => new { name = fname, file, @params = ownedParams, body = fbody }, - (null, false) => new { name = fname, file, body = fbody }, - }); + // P-037 A2.1 (#304): the guarded-fact sidecar — raw call-argument and guard + // facts, keyed by declared parameter ordinal, VALIDATED AND INERT in A2 (the + // legacy `body` stays authoritative; see BuildGuardedFacts). It rides only + // when this method has a relevant call or an eligible guard, so every other + // record keeps the shape it had. Key order is fixed (name, file, sig, params, + // body, guarded_facts): the two doors read by name, the fact digest by bytes. + // Handles for the sidecar are the disposable CANDIDATES, not the post-escape + // `tracked` set: a local the legacy pass untracked because it was handed to a + // non-consuming callee is exactly the handle whose flow a summary refines. + var guardedFacts = BuildGuardedFacts(method, mbody, candidates, ownedParamNames, + model, fname); + var record = new Dictionary { ["name"] = fname, ["file"] = file }; + if (fsig is not null) + record["sig"] = fsig; + if (ownedParams.Count > 0) + record["params"] = ownedParams; + record["body"] = fbody; + if (guardedFacts is not null) + record["guarded_facts"] = guardedFacts; + flowFunctions.Add(record); } if (subs.Count > 0) @@ -6789,6 +7176,16 @@ or ImplicitObjectCreationExpressionSyntax } init functions = flowFunctions, stats = factStats, }; +// P-037 A2.1: a sidecar record that does not satisfy its own vocabulary is a producer +// defect, and a producer defect must not become a facts file. Refuse the whole run +// (exit 2, the launcher's "extraction failed, no verdict was produced" tier) rather +// than hand either door a document one half of which is wrong. +if (GuardedFactsViolations.Count > 0) +{ + foreach (var violation in GuardedFactsViolations) + Console.Error.WriteLine($"extractor: guarded_facts self-check failed: {violation}"); + return 2; +} var json = JsonSerializer.Serialize(facts, new JsonSerializerOptions { WriteIndented = true }); if (reportStats) @@ -6814,6 +7211,21 @@ partial class Program // to the .csproj, not above the linked file). internal static readonly HashSet WeaverOwnedFiles = new(StringComparer.Ordinal); + // P-037 A2.1: violations of the guarded-fact sidecar's own vocabulary, collected while + // records are built and turned into a refusal to write facts at all (see the check + // before serialization). A list rather than a throw so the message names every + // offending site of a run, not only the first. + internal static readonly List GuardedFactsViolations = new(); + + // The sidecar's closed vocabularies (spec/ownir.schema.json $defs/guardedArg etc. mirror + // these; tests/test_p037_sidecar.py pins the two against each other). + internal static readonly HashSet GuardedArgKinds = new(StringComparer.Ordinal) + { "var", "param", "bool_const", "null_literal", "object_creation", "call_result", "opaque" }; + internal static readonly HashSet GuardPredicates = new(StringComparer.Ordinal) + { "truth", "not_null", "is_null" }; + internal static readonly HashSet CallForms = new(StringComparer.Ordinal) + { "statement", "initializer", "expression" }; + // #317: a 1-based source coordinate, carried as ONE value so a line and a column can // never drift onto different nodes. See RangeOf/PosOf/LineOf above — those are the only // producers of these, and they are computed from a single GetLineSpan() per node. diff --git a/pyproject.toml b/pyproject.toml index 7cd05f29..d3e84c89 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,6 +48,7 @@ files = [ "scripts/p037_mos_snapshot.py", "scripts/p037_verdict_snapshot.py", "scripts/p037_fact_shapes.py", + "scripts/p037_sidecar_inertness.py", "scripts/round7/classify.py", "scripts/round7/elfread.py", "scripts/round7/preflight.py", diff --git a/scripts/p037_fact_shapes.py b/scripts/p037_fact_shapes.py index fce9c68e..abe1108c 100755 --- a/scripts/p037_fact_shapes.py +++ b/scripts/p037_fact_shapes.py @@ -98,6 +98,9 @@ def observe_facts(case: Path) -> dict[str, Any]: fn["name"]: { "params": fn.get("params"), "body": flatten(fn.get("body", [])), + # P-037 A2.1: the guarded-fact sidecar, whole. It is the fact surface a2 + # exists to add, so it is pinned per shape exactly like the body ops. + "guarded_facts": fn.get("guarded_facts"), } for fn in doc.get("functions", []) } @@ -120,6 +123,53 @@ def observe_verdict(case: Path, engine: str) -> list[str]: return sorted(out) +def _subset(expected: Any, observed: Any) -> bool: + """`expected` is contained in `observed`: dicts by key, lists element-wise, scalars ==.""" + if isinstance(expected, dict): + return isinstance(observed, dict) and all( + k in observed and _subset(v, observed[k]) for k, v in expected.items()) + if isinstance(expected, list): + return (isinstance(observed, list) and len(expected) == len(observed) + and all(_subset(e, o) for e, o in zip(expected, observed, strict=True))) + return bool(expected == observed) + + +def a2_problems(spec: dict[str, Any], facts: dict[str, Any]) -> list[str]: + """The a2 CONTRACT of a shape, checked by name rather than by blob equality. + + `facts` already pins the whole sidecar byte for byte; `a2_expect` states what + the contract prose promised, so a shape that drifts fails with the promise + it broke in the message, not with a JSON diff someone has to interpret. + """ + problems: list[str] = [] + for exp in spec.get("a2_expect", []): + fn = exp.get("function") + rec = facts.get(fn) if isinstance(fn, str) else None + if rec is None: + problems.append(f"{fn}: no function record") + continue + gf = rec.get("guarded_facts") + if exp.get("guarded_facts") == "absent": + if gf is not None: + problems.append( + f"{fn}: expected NO guarded_facts (absence is the signal), got some") + continue + if exp.get("guards") == "absent" and gf is not None and gf.get("guards"): + problems.append(f"{fn}: expected no eligible guard, got {gf.get('guards')}") + if exp.get("calls") == "absent" and gf is not None and gf.get("calls"): + problems.append(f"{fn}: expected no relevant call, got {gf.get('calls')}") + for key, want in (("call", exp.get("call")), ("guard", exp.get("guard"))): + if want is None: + continue + pool = (gf or {}).get(key + "s") or [] + hits = [c for c in pool if _subset(want, c)] + if len(hits) != 1: + problems.append( + f"{fn}: expected exactly one {key} matching {json.dumps(want)}, " + f"found {len(hits)} in {json.dumps(pool)}") + return problems + + def cases(only: set[str]) -> list[Path]: return sorted(p for p in SHAPES.iterdir() if p.is_dir() and (p / "case.cs").exists() @@ -172,8 +222,15 @@ def check(only: set[str], engines: list[str]) -> int: ok = False print(f"VERDICT MOVED {c.name} [{tag}] engine={e}: " f"recorded {want}, observed {got}") + contract = a2_problems(spec, facts) + for problem in contract: + print(f" a2 contract: {problem}") + if contract: + ok = False + failures += 1 if ok: - print(f"ok {c.name:28} [{tag}] {len(facts)} record(s)") + print(f"ok {c.name:28} [{tag}] {len(facts)} record(s), " + f"{len(spec.get('a2_expect', []))} contract check(s)") total = len(cases(only)) if failures: print(f"\nRESULT: {failures} difference(s) over {total} shape(s). A shape that " diff --git a/scripts/p037_sidecar_inertness.py b/scripts/p037_sidecar_inertness.py new file mode 100755 index 00000000..8d1dcaaf --- /dev/null +++ b/scripts/p037_sidecar_inertness.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""P-037 A2.1 inertness control: the guarded-fact sidecar changes NOTHING an engine says. + +The A2 staging invariant (docs/notes/p037-formal-kernel.md §10.3) is that the +sidecar is validated but semantically inert through A2: the legacy `body` stays +authoritative, and neither the MOS documents nor the verdicts may move because +the sidecar is present, absent, or WRONG. This control runs that sentence. + +For every shape in corpus/p037-shapes and for the repository's own samples +(one Roslyn compilation, the dogfood input), the extractor runs once and three +documents are derived from its bytes: + + emitted the facts exactly as the extractor wrote them, sidecar included + stripped the same document with every `guarded_facts` removed + contradictory the same document with a sidecar that LIES: booleans flipped, + forwarded parameters negated, guard predicates swapped, and one + fabricated guard added to every function that had none + +Each document goes through BOTH engines by the P-022 capture protocol +(ownlang.repro.capture for Python, the own-shadow-engine adapter for Rust); the +lowered, summaries and verdicts layers must be identical across the three +documents on each engine, and Python must equal Rust on each. A difference is a +semantic cut that began early, and the answer to that is to isolate it, never to +note that the verdicts happened to agree. + +Run: python scripts/p037_sidecar_inertness.py [--only NAME,...] + (needs dotnet for the extractor and a built own-shadow-engine; the CI + dogfood step builds the latter via `p037_evidence.py artifacts` first) +""" + +from __future__ import annotations + +import argparse +import copy +import json +import subprocess +import sys +import tempfile +from pathlib import Path +from typing import Any + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT)) + +import p037_evidence as ev # noqa: E402 +from shadow_compare import ( # noqa: E402 + DEFAULT_TIMEOUT_SECONDS, + engine_identity, + resolve_engine_binary, + run_port, + run_reference, +) + +SHAPES = ROOT / "corpus" / "p037-shapes" +SAMPLES = ROOT / "frontend" / "roslyn" / "samples" +LAYERS = ("lowered", "summaries", "verdicts") + + +def extract(inputs: list[Path]) -> bytes: + with tempfile.TemporaryDirectory(prefix="p037-inert-") as td: + out = Path(td) / "facts.json" + project = ROOT / "frontend" / "roslyn" / "OwnSharp.Extractor" + cmd = ["dotnet", "run", "--project", str(project), "--", + *(str(p) for p in inputs), "--flow-locals", "-o", str(out)] + proc = subprocess.run(cmd, capture_output=True, text=True, check=False, cwd=ROOT, + env=ev.sanitized_env()) + if proc.returncode != 0 or not out.exists(): + tail = proc.stderr.strip()[-600:] + raise RuntimeError(f"extractor failed ({proc.returncode}): {tail}") + return out.read_bytes() + + +def stripped(doc: dict[str, Any]) -> dict[str, Any]: + out = copy.deepcopy(doc) + for fn in out.get("functions", []): + fn.pop("guarded_facts", None) + return out + + +def contradictory(doc: dict[str, Any]) -> dict[str, Any]: + """A sidecar that is valid vocabulary and wrong about everything it can be wrong about.""" + out = copy.deepcopy(doc) + swap = {"truth": "not_null", "not_null": "is_null", "is_null": "truth"} + for fn in out.get("functions", []): + gf = fn.get("guarded_facts") + if not isinstance(gf, dict): + gf = {"version": 1, "calls": [], "guards": []} + fn["guarded_facts"] = gf + for call in gf.get("calls", []): + for arg in call.get("args", []): + if arg.get("kind") == "bool_const": + arg["value"] = not arg["value"] + elif arg.get("kind") == "param": + if arg.pop("negated", None) is None: + arg["negated"] = True + elif arg.get("kind") == "var": + arg["kind"] = "object_creation" + arg.pop("name", None) + elif arg.get("kind") == "opaque": + arg["kind"] = "null_literal" + for guard in gf.get("guards", []): + guard["predicate"] = swap[guard["predicate"]] + guard["negated"] = not guard["negated"] + gf["guards"].append({"site": {"line": 1, "column": 1}, "param": 0, + "predicate": "truth", "negated": False}) + return out + + +def layers_of(entry: dict[str, Any]) -> dict[str, Any]: + layers = entry.get("layers") + if not isinstance(layers, list): + raise RuntimeError("capture has no layers") + return {str(layer.get("layer")): layer for layer in layers if isinstance(layer, dict)} + + +def capture_both(raw: bytes, adapter: dict[str, Any], timeout: float + ) -> tuple[dict[str, Any], dict[str, Any]]: + reference = run_reference(raw) + py = reference.get("entry") + if not isinstance(py, dict): + raise RuntimeError( + f"Python capture refused the document: {reference.get('canonical_error')}") + envelope = run_port(raw, adapter, timeout).get("envelope") + if not isinstance(envelope, dict) or not isinstance(envelope.get("engine"), dict): + raise RuntimeError("Rust adapter returned no engine capture") + return layers_of(py), layers_of(envelope["engine"]) + + +def documents(only: set[str]) -> list[tuple[str, list[Path]]]: + docs = [(p.name, [p / "case.cs"]) for p in sorted(SHAPES.iterdir()) + if p.is_dir() and (p / "case.cs").exists() and (not only or p.name in only)] + if not only or "samples" in only: + docs.append(("samples", sorted(SAMPLES.glob("*.cs")))) + return docs + + +def main(argv: list[str]) -> int: + ap = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--only", default="", help="comma-separated shape names (and/or `samples`)") + ap.add_argument("--engine-binary", default=None) + ap.add_argument("--timeout", type=float, default=DEFAULT_TIMEOUT_SECONDS) + args = ap.parse_args(argv) + only = {x for x in args.only.split(",") if x} + try: + adapter = engine_identity(resolve_engine_binary(args.engine_binary)) + except SystemExit as exc: + print(f"REFUSED: {exc}", file=sys.stderr) + return 2 + + failures = 0 + checked = 0 + sidecars = 0 + for name, inputs in documents(only): + try: + raw = extract(inputs) + emitted = json.loads(raw) + carried = sum(1 for fn in emitted.get("functions", []) if "guarded_facts" in fn) + sidecars += carried + variants = { + "emitted": raw, + "stripped": json.dumps(stripped(emitted)).encode("utf-8"), + "contradictory": json.dumps(contradictory(emitted)).encode("utf-8"), + } + captured = {label: capture_both(b, adapter, args.timeout) + for label, b in variants.items()} + except (RuntimeError, OSError, ValueError) as exc: + failures += 1 + print(f"FAIL[{name}]: {exc}") + continue + problems: list[str] = [] + base_py, base_rs = captured["emitted"] + for layer in LAYERS: + for label, (py, rs) in captured.items(): + if layer not in py or layer not in rs: + problems.append(f"{label}: no {layer} layer") + continue + if py[layer] != base_py[layer]: + problems.append(f"python {layer} differs between emitted and {label}") + if rs[layer] != base_rs[layer]: + problems.append(f"rust {layer} differs between emitted and {label}") + if py[layer] != rs[layer]: + problems.append(f"{label}: python and rust {layer} layers differ") + checked += 1 + if problems: + failures += 1 + print(f"FAIL[{name}]: " + "; ".join(sorted(set(problems)))) + else: + print(f"ok[{name}] {len(inputs)} file(s), {carried} sidecar(s): emitted == stripped == " + f"contradictory on {len(LAYERS)} layers, python == rust") + if checked and sidecars == 0: + failures += 1 + print("FAIL[non-vacuous]: no function carried a sidecar, so nothing was tested") + if failures: + print(f"RESULT: {failures} inertness control(s) failed") + return 1 + print(f"RESULT: the guarded-fact sidecar is inert on both engines ({checked} document(s), " + f"{sidecars} sidecar(s))") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/spec/OwnIR.md b/spec/OwnIR.md index ac0ab14e..3dcc538b 100644 --- a/spec/OwnIR.md +++ b/spec/OwnIR.md @@ -226,6 +226,16 @@ contract question that recorded ("whether a coordinate no rule reads should nevertheless be well-formed") is answered **yes**, because the tolerant door does read it and anchors findings on it. +One line-bearing path is, deliberately, validated by **neither door** for now: +the `site` of a guarded-fact sidecar entry (`functions[].guarded_facts`, §5.2). +The P-037 A2 staging contract makes that sidecar inert at both doors in A2.1 — +`load()` never reads the key and the Rust door carries it as an unknown field — +so a domain the door does not check is not stated by the schema either +(`sourceSite` binds neither `sourceLine` nor `sourceColumn` and states only +the type); the producer refuses to write a record whose line or column is +below 1. The instrument step that registers the sidecar at the doors binds +both coordinates to the domain above, at which point this paragraph goes. + **Flow bodies and protocol event trees nest at most 32 levels.** `functions[].body` and `protocol_functions[].events` nest through `then`, @@ -308,6 +318,78 @@ behaviour) — degraded, never a wrong overload — and the `first_party` / Additive/optional per §2: no `OWNIR_VERSION` bump; a present-but-non-string `sig` on a function record is rejected at load, on a flow op it reads as absent. +### 5.2 The guarded-fact sidecar (`guarded_facts`, P-037 A2.1) + +A flow function may carry an **optional** `guarded_facts` object: the frontend's +raw record of what flows into each *relevant* call of the method and what each +`if` tests. It is the input the guarded summary engine of P-037 (#304) reads +once phase B wires it; through A2 it is **validated and semantically inert** — +neither engine reads it, `body` stays authoritative, and a run's MOS documents +and verdicts must not move when it appears +(`docs/notes/p037-formal-kernel.md` §10.3; the A2 baselines under +`docs/evidence/` are the witness, `corpus/p037-shapes` pins it per shape). +Additive/optional per §2: no `OWNIR_VERSION` bump. The JSON Schema +(`$defs/guardedFacts`, `guardedCall`, `guardedArg`, `guardedGuard`) is the +normative shape; this section is its meaning. + +Two rules govern every field (P-037 §10.2, the raw-fact boundary): + +- **Roslyn reports source facts, never P-037 interpretations.** `bool_const true` + is a fact; `const-pos` is an interpretation relative to the callee's *elected* + guard and belongs to the engine. `param` names the caller's own parameter by + declared ordinal; whether that is an `id` or a `neg` edge is the engine's + reading. There is no `fresh_owned`: a call result is `call_result{callee,sig}` + and freshness is a summary conclusion. +- **Absence is the fail-closed signal.** A guard that is not eligible — G-V1: a + by-value boolean parameter, or the null-ness of a by-value reference (or + nullable) parameter, the self-null split included; G-V4: the parameter is never + assigned, incremented, taken by `ref`, or passed by `ref`/`out` anywhere in the + body — gets **no** entry, never `stable: false`, so an old producer, an + unstable parameter, an unsupported predicate and unknown syntax all degrade the + same way. The same stability rule decides whether an *argument* naming a + parameter is a `param` fact or `opaque`. + +```text +guarded_facts: + version 1 + calls[] one per RELEVANT call: a disposable local of this method (any + candidate, escaped or not) or an owned parameter flows in, as an + argument or as a reduced extension method's receiver + site {line, column} — start of the invocation expression (identity) + statement_line the enclosing statement's line (what the legacy ops carry) + form statement | initializer | expression + callee, sig the resolved method's functions[] key and §5.1 signature, or null + first_party the callee has a declaration in this compilation + args[] by DECLARED PARAMETER ORDINAL, strictly ascending: + var{name} a disposable local of this method + param{source_param[,negated]} a stable by-value parameter (`!p` -> negated) + bool_const{value} a boolean literal + null_literal · object_creation + call_result{callee,sig} the result of a resolved call + opaque everything else + guards[] one per ELIGIBLE `if`: {site, param, predicate, negated} + predicate: truth | not_null | is_null +``` + +Binding rules: a named argument resolves to its parameter; a reduced extension's +receiver is ordinal 0 (the unreduced declaration is the summary's home); an +argument bound to a `params` array collapses to one `opaque` slot; an omitted +optional argument has no entry; a `ref`/`out` argument is `opaque`. For an +**unresolved** callee (`callee: null`) the ordinal is the *source position* — +there is no declaration to bind against, and the record says so rather than +guessing. Calls inside lambdas and local functions belong to those bodies, not +to the method. + +The call-site identity — the invocation's own coordinate plus `statement_line` — +is what lets the legacy view (`body`) and this one be joined until the C+ +checkpoint canonicalizes the two representations (§10.5 of the formal note). +Both coordinates of a `site` are 1-based, and in A2.1 they are validated +**only** by the producer: the doors do not read the sidecar yet (§4.2), so +`sourceSite` states their type and nothing narrower until the instrument step +that registers the sidecar binds them to the shared coordinate domain. +The producer validates every record against this vocabulary and refuses to +write a facts file at all if one is malformed (exit 2): fail-loud at the source. + ## 6. DI registration graph (`services[]`) An optional array feeding the **DI001** captive-dependency check (P-006), a diff --git a/spec/ownir.schema.json b/spec/ownir.schema.json index bcc4fb1c..34896ccd 100644 --- a/spec/ownir.schema.json +++ b/spec/ownir.schema.json @@ -167,7 +167,11 @@ "description": "An ordered list of flow ops modelling the method's intra-procedural CFG.", "type": "array", "items": { "$ref": "#/$defs/flowOp" } - } + }, + "guarded_facts": { + "$ref": "#/$defs/guardedFacts", + "description": "P-037 A2.1 (#304): the guarded-fact SIDECAR — the frontend's raw record of what flows into each relevant call and what each `if` tests. Additive/optional, no OWNIR_VERSION bump. In A2 it is validated and semantically INERT: neither engine reads it, `body` stays authoritative, and MOS documents and verdicts must not move when it appears (docs/notes/p037-formal-kernel.md §10.3). Prose: spec/OwnIR.md §5.2." + } } }, "param": { @@ -492,6 +496,272 @@ "file": { "type": "string" }, "events": { "type": "array", "items": { "$ref": "#/$defs/protocolEvent" } } } - } + }, + "sourceSite": { + "type": "object", + "required": [ + "line", + "column" + ], + "additionalProperties": false, + "properties": { + "line": { + "type": "integer" + }, + "column": { + "type": "integer" + } + }, + "description": "A 1-based start coordinate of a syntax node: the stable identity of a call site or a guard within the record's `file` (P-037 A2.1). Deliberately NOT bound to sourceLine/sourceColumn: in A2.1 the sidecar is inert at both doors (spec/OwnIR.md \u00a74.2, \u00a75.2) \u2014 `load()` never reads this path \u2014 and \u00a74.2 forbids a schema narrower than the door on a coordinate the door does not check. The producer refuses to write a record whose line or column is below 1 (exit 2). The instrument step that registers the sidecar at the doors binds both to the shared coordinate domain." + }, + "guardedFacts": { + "type": "object", + "required": [ + "version", + "calls", + "guards" + ], + "additionalProperties": false, + "properties": { + "version": { + "const": 1, + "description": "Sidecar vocabulary version. A consumer that has learned the sidecar refuses any other value (fail-loud); one that has not ignores the whole field." + }, + "calls": { + "type": "array", + "items": { + "$ref": "#/$defs/guardedCall" + } + }, + "guards": { + "type": "array", + "items": { + "$ref": "#/$defs/guardedGuard" + } + } + }, + "description": "P-037 A2.1: raw call-argument and guard facts of one flow function, keyed by declared parameter ordinal. Present only when the method has a relevant call or an eligible guard. Roslyn reports source facts, never P-037 interpretations (no const-pos/id/neg, no fresh_owned); absence is the fail-closed signal (no `stable: false`)." + }, + "guardedCall": { + "type": "object", + "required": [ + "site", + "statement_line", + "form", + "callee", + "sig", + "first_party", + "args" + ], + "additionalProperties": false, + "properties": { + "site": { + "$ref": "#/$defs/sourceSite", + "description": "Start of the invocation expression." + }, + "statement_line": { + "type": "integer", + "minimum": 0, + "maximum": 2147483647, + "description": "Line of the enclosing statement: the coordinate the legacy body ops carry, so the legacy view and this one can be joined until C+ canonicalizes them (§10.5)." + }, + "form": { + "enum": [ + "statement", + "initializer", + "expression" + ], + "description": "statement: `Foo(s);` (or `await Foo(s);`); initializer: `var x = Foo(s)`, the only form the legacy body may carry a `call` op for; expression: anywhere else." + }, + "callee": { + "type": [ + "string", + "null" + ], + "description": "The `functions[]` key of the resolved method (`{Namespace.Type}.{Name}`); null when Roslyn could not resolve the call, in which case `args[].param` is the SOURCE position." + }, + "sig": { + "type": [ + "string", + "null" + ], + "description": "The canonical per-overload signature key (§5.1) of the resolved method; null when unresolved." + }, + "first_party": { + "type": "boolean", + "description": "The resolved method has a declaration in this compilation (a summary can exist for it)." + }, + "args": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/guardedArg" + }, + "description": "One raw fact per bound argument, ordered by strictly ascending declared parameter ordinal. A reduced extension's receiver is ordinal 0; an omitted optional argument has no entry; a `params` expansion is one `opaque` slot." + } + } + }, + "guardedArg": { + "type": "object", + "required": [ + "param", + "kind" + ], + "properties": { + "param": { + "type": "integer", + "minimum": 0, + "description": "Declared parameter ordinal (source position for an unresolved callee)." + }, + "kind": { + "enum": [ + "var", + "param", + "bool_const", + "null_literal", + "object_creation", + "call_result", + "opaque" + ] + } + }, + "oneOf": [ + { + "properties": { + "param": true, + "kind": { + "const": "var" + }, + "name": { + "type": "string", + "minLength": 1 + } + }, + "required": [ + "name" + ], + "additionalProperties": false, + "description": "A disposable local of this method flows in, by name (its handle)." + }, + { + "properties": { + "param": true, + "kind": { + "const": "param" + }, + "source_param": { + "type": "integer", + "minimum": 0 + }, + "negated": { + "const": true + } + }, + "required": [ + "source_param" + ], + "additionalProperties": false, + "description": "A STABLE (G-V4) by-value parameter of this method, by declared ordinal; `negated` only for `!p` on a boolean parameter. The engine reads `id` or `neg` from this; the frontend never writes those words." + }, + { + "properties": { + "param": true, + "kind": { + "const": "bool_const" + }, + "value": { + "type": "boolean" + } + }, + "required": [ + "value" + ], + "additionalProperties": false, + "description": "A boolean literal. `const-pos`/`const-neg` is the engine's reading relative to the callee's elected guard." + }, + { + "properties": { + "param": true, + "kind": { + "const": "null_literal" + } + }, + "additionalProperties": false + }, + { + "properties": { + "param": true, + "kind": { + "const": "object_creation" + } + }, + "additionalProperties": false + }, + { + "properties": { + "param": true, + "kind": { + "const": "call_result" + }, + "callee": { + "type": "string", + "minLength": 1 + }, + "sig": { + "type": "string" + } + }, + "required": [ + "callee", + "sig" + ], + "additionalProperties": false, + "description": "The result of a resolved call. Freshness is a summary conclusion, never a frontend fact: there is no `fresh_owned` in this vocabulary (§10.2)." + }, + { + "properties": { + "param": true, + "kind": { + "const": "opaque" + } + }, + "additionalProperties": false, + "description": "Everything else: an unstable parameter, a `ref`/`out` argument, a `params` expansion, a non-boolean literal, an untracked local, an unresolved name." + } + ] + }, + "guardedGuard": { + "type": "object", + "required": [ + "site", + "param", + "predicate", + "negated" + ], + "additionalProperties": false, + "properties": { + "site": { + "$ref": "#/$defs/sourceSite", + "description": "Start of the `if` statement (the legacy `if` op's line)." + }, + "param": { + "type": "integer", + "minimum": 0, + "description": "Declared ordinal of the by-value parameter the condition tests. Eligible (G-V1) and stable (G-V4) by construction: an ineligible guard has NO entry, never `stable: false`." + }, + "predicate": { + "enum": [ + "truth", + "not_null", + "is_null" + ], + "description": "truth: the boolean parameter itself; not_null / is_null: `p != null`, `p == null`, `p is null`, `p is not null` on a reference or nullable parameter, the self-null split included." + }, + "negated": { + "type": "boolean", + "description": "`!p` (truth only). A negated null test is not a predicate here: it degrades to absence." + } + } + } } } diff --git a/tests/test_ownir_defensive_limits.py b/tests/test_ownir_defensive_limits.py index 19bf1e78..4dfa4f37 100644 --- a/tests/test_ownir_defensive_limits.py +++ b/tests/test_ownir_defensive_limits.py @@ -247,16 +247,23 @@ def run() -> int: # # So the map is asserted as a map, not spot-checked. # - # `UNBOUND` is EMPTY since #259's final acceptance: §4.2's exception is - # closed and every coordinate-bearing path is checked by `load()`. The - # machinery stays rather than being deleted with its last entry, because - # what it enforces is that a path is *classified* — the next unbound path - # somebody adds must be declared here, not discovered by nobody. + # `UNBOUND` was EMPTY from #259's final acceptance (§4.2's exception closed, + # every coordinate-bearing path checked by `load()`) until P-037 A2.1, which + # re-opened it on purpose with exactly one entry: the guarded-fact sidecar's + # `site` (§5.2). The A2 staging contract makes the sidecar inert at both + # doors in A2.1 — `load()` never reads `functions[].guarded_facts`, and the + # Rust door carries it as an unknown field — so binding its coordinate here + # would make a producer schema-invalid on a path the door accepts, which is + # the first of the two defects this map exists to catch. The producer's own + # self-check refuses a line or column below 1. The instrument step that + # registers the sidecar at the doors moves this entry to BOUND; until then + # the machinery is doing what it was kept for: the next unbound path is + # declared here, not discovered by nobody. BOUND = {"service": ["line", "ctor_line"], "site": ["line"], "effect": ["line"], "binding": ["line"], "param": ["line"], "protocolEvent": ["line"], "resourceRecord": ["line"], "flowOp": ["line"]} - UNBOUND: dict[str, list[str]] = {} + UNBOUND: dict[str, list[str]] = {"sourceSite": ["line"]} # …and the map is CLOSED over the schema, which the per-member checks below # cannot establish on their own. diff --git a/tests/test_p037_sidecar.py b/tests/test_p037_sidecar.py new file mode 100644 index 00000000..e2f4acd6 --- /dev/null +++ b/tests/test_p037_sidecar.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""P-037 A2.1: the guarded-fact sidecar's vocabulary is ONE vocabulary. + +Three places spell it: the JSON Schema (`spec/ownir.schema.json`), the producer +(`frontend/roslyn/OwnSharp.Extractor/Program.cs`, the closed sets its +self-check validates against) and the prose (`spec/OwnIR.md` §5.2). The core is +zero-dependency, so documents are not validated against the schema here; the +spellings are pinned against each other instead, the way tests/test_ownir.py +pins the resource-kind and flow-op enums. A kind added to the producer without +the schema, or to the schema without the producer, reddens this build. + +Run: python tests/test_p037_sidecar.py + python tests/run_tests.py (in the suite) +""" + +from __future__ import annotations + +import json +import re +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +SCHEMA = ROOT / "spec" / "ownir.schema.json" +EXTRACTOR = ROOT / "frontend" / "roslyn" / "OwnSharp.Extractor" / "Program.cs" +PROSE = ROOT / "spec" / "OwnIR.md" + +failures = 0 + + +def check(name: str, condition: bool, detail: str) -> None: + global failures + if condition: + print(f"ok[{name}]") + else: + failures += 1 + print(f"FAIL[{name}]: {detail}") + + +def csharp_set(source: str, field: str) -> set[str]: + """The string literals of `static readonly HashSet = new(...) {...};`.""" + pattern = rf"HashSet {field} = new\(StringComparer\.Ordinal\)\s*\{{([^}}]*)\}}" + m = re.search(pattern, source) + if not m: + return set() + return set(re.findall(r'"([^"]+)"', m.group(1))) + + +def main() -> int: + schema = json.loads(SCHEMA.read_text(encoding="utf-8")) + defs = schema.get("$defs", {}) + source = EXTRACTOR.read_text(encoding="utf-8") + prose = PROSE.read_text(encoding="utf-8") + + fn_props = defs.get("function", {}).get("properties", {}) + check("function-carries-guarded_facts", + fn_props.get("guarded_facts", {}).get("$ref") == "#/$defs/guardedFacts", + "functions[].guarded_facts must reference $defs/guardedFacts") + gf = defs.get("guardedFacts", {}) + check("sidecar-is-closed", + gf.get("additionalProperties") is False + and set(gf.get("required", [])) == {"version", "calls", "guards"} + and gf.get("properties", {}).get("version", {}).get("const") == 1, + "guardedFacts must be a closed object {version: 1, calls, guards}") + + arg = defs.get("guardedArg", {}) + schema_kinds = set(arg.get("properties", {}).get("kind", {}).get("enum", [])) + producer_kinds = csharp_set(source, "GuardedArgKinds") + check("arg-kinds-schema-equals-producer", + schema_kinds == producer_kinds and bool(producer_kinds), + f"schema {sorted(schema_kinds)} != producer {sorted(producer_kinds)}") + branches = arg.get("oneOf", []) + branch_kinds = [b.get("properties", {}).get("kind", {}).get("const") for b in branches] + check("arg-kinds-each-have-one-closed-branch", + sorted(k for k in branch_kinds if k) == sorted(schema_kinds) + and all(b.get("additionalProperties") is False for b in branches), + f"oneOf branches {branch_kinds} must cover every kind exactly once, each closed") + guard = defs.get("guardedGuard", {}) + schema_preds = set(guard.get("properties", {}).get("predicate", {}).get("enum", [])) + producer_preds = csharp_set(source, "GuardPredicates") + check("guard-predicates-schema-equals-producer", + schema_preds == producer_preds and bool(producer_preds), + f"schema {sorted(schema_preds)} != producer {sorted(producer_preds)}") + check("guard-is-closed", + guard.get("additionalProperties") is False + and set(guard.get("required", [])) == {"site", "param", "predicate", "negated"}, + "guardedGuard must be a closed object {site, param, predicate, negated}") + call = defs.get("guardedCall", {}) + schema_forms = set(call.get("properties", {}).get("form", {}).get("enum", [])) + producer_forms = csharp_set(source, "CallForms") + check("call-forms-schema-equals-producer", + schema_forms == producer_forms and bool(producer_forms), + f"schema {sorted(schema_forms)} != producer {sorted(producer_forms)}") + check("call-is-closed-and-keyed", + call.get("additionalProperties") is False + and set(call.get("required", [])) == {"site", "statement_line", "form", "callee", + "sig", "first_party", "args"} + and call.get("properties", {}).get("args", {}).get("minItems") == 1, + "guardedCall must be closed, fully required, with at least one argument") + + # The raw-fact boundary (P-037 §10.2) in the vocabulary itself: no P-037 + # interpretation and no synthetic freshness may be spellable. + forbidden = {"const-pos", "const_pos", "const-neg", "const_neg", "id", "neg", "fresh_owned", + "fresh", "stable"} + leaked = forbidden & (schema_kinds | schema_preds | schema_forms + | {k for b in branches for k in b.get("properties", {})}) + check("raw-fact-boundary-holds", not leaked, + f"interpretation vocabulary leaked into the sidecar: {sorted(leaked)}") + + check("prose-documents-the-sidecar", + "### 5.2" in prose and all(k in prose for k in schema_kinds | schema_preds), + "spec/OwnIR.md §5.2 must name every kind and predicate") + + if failures: + print(f"RESULT: {failures} sidecar vocabulary check(s) failed") + return 1 + print("RESULT: guarded-fact sidecar vocabulary is one vocabulary " + "across schema, producer and prose") + return 0 + + +def run() -> int: + """Entry point required by tests/run_tests.py's test_*.py census.""" + return main() + + +if __name__ == "__main__": + raise SystemExit(run()) From 5a0de070af241a2612859153887ad6ae04afcce2 Mon Sep 17 00:00:00 2001 From: PhysShell Date: Sat, 19 Sep 2026 06:30:10 +0000 Subject: [PATCH 2/3] P-037 A2.1: decouple call relevance from argument representability MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit BuildGuardedFacts coupled two independent questions: whether a call is RELEVANT (a tracked/owned handle syntactically flows into it) and how precisely an argument slot can be REPRESENTED (param/var/opaque). Both the params/ref-or-out branch and the unstable-owned-parameter branch in ArgFact hardcoded the handle bit to `false` whenever the slot had to be opaque, so a handle passed through a `params` array, by `ref`/`out`, or as an unstable owned parameter never set `relevant`, and the entire call record silently vanished from guarded_facts instead of surviving with an opaque slot for that argument — contradicting spec/OwnIR.md §5.2, which says an unrepresentable argument becomes opaque, not absent. Fix: evaluate the argument's handle-ness once, independent of how the slot ends up encoded, and thread that value through both branches. Adds three regression shapes to corpus/p037-shapes (a params sink, a ref sink, and an unstable owned parameter flowing to a normal argument), each asserting the call record exists with an opaque slot, not merely that the slot's kind is opaque. Verified against the pre-fix code first (all three reproduced the bug: guarded_facts entirely absent for the method), then against the fix (all three now carry the call record). Full existing 11-shape census, the dedicated sidecar vocabulary test, and the sidecar inertness control (both engines) all still pass unchanged: the sidecar remains semantically inert. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_011wKL9pEApQTK4dE3eXv8g8 --- .../sidecar-relevance-params-handle/case.cs | 24 ++++++ .../expected.json | 58 +++++++++++++++ .../sidecar-relevance-refout-handle/case.cs | 23 ++++++ .../expected.json | 57 +++++++++++++++ .../sidecar-relevance-unstable-owned/case.cs | 22 ++++++ .../expected.json | 73 +++++++++++++++++++ frontend/roslyn/OwnSharp.Extractor/Program.cs | 18 +++-- 7 files changed, 269 insertions(+), 6 deletions(-) create mode 100644 corpus/p037-shapes/sidecar-relevance-params-handle/case.cs create mode 100644 corpus/p037-shapes/sidecar-relevance-params-handle/expected.json create mode 100644 corpus/p037-shapes/sidecar-relevance-refout-handle/case.cs create mode 100644 corpus/p037-shapes/sidecar-relevance-refout-handle/expected.json create mode 100644 corpus/p037-shapes/sidecar-relevance-unstable-owned/case.cs create mode 100644 corpus/p037-shapes/sidecar-relevance-unstable-owned/expected.json diff --git a/corpus/p037-shapes/sidecar-relevance-params-handle/case.cs b/corpus/p037-shapes/sidecar-relevance-params-handle/case.cs new file mode 100644 index 00000000..cebefd7f --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-params-handle/case.cs @@ -0,0 +1,24 @@ +// A tracked handle flowing into a `params` slot is unrepresentable precisely +// (the slot must be opaque, per spec/OwnIR.md §5.2), but it still flowed: the +// call record must exist, not vanish. Relevance and representability are +// orthogonal. `keep` is a second, non-escaping local purely so the method +// still gets flow-analysed at all (a method whose only tracked local fully +// escapes into a non-consuming callee is legitimately skipped upstream of +// the guarded-fact sidecar; that is unrelated to what this shape tests). +using System.IO; + +static class ShapeParamsHandle +{ + static void Sink(params Stream[] xs) + { + } + + static void Caller(string path) + { + var keep = File.OpenRead(path); + var s = File.OpenRead(path); + Sink(s); + keep.Dispose(); + s.Dispose(); + } +} diff --git a/corpus/p037-shapes/sidecar-relevance-params-handle/expected.json b/corpus/p037-shapes/sidecar-relevance-params-handle/expected.json new file mode 100644 index 00000000..669a973d --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-params-handle/expected.json @@ -0,0 +1,58 @@ +{ + "schema": "p037-fact-shape/1", + "shape": "sidecar-relevance-params-handle", + "status": "anchored", + "why": "Regression for a relevance/opacity coupling bug in BuildGuardedFacts: a handle bound to a `params` slot is unrepresentable precisely (must be `opaque`), but the producer also zeroed the slot's HANDLE bit, so the whole call vanished from guarded_facts instead of surviving as an opaque-argument call. Relevance (\"a tracked handle syntactically flows here\") and representability (how precisely the slot can be encoded) must be orthogonal.", + "a2_contract": "The call to a `params` sink stays in guarded_facts.calls[] with an opaque slot for the handle argument; it must not be silently dropped just because the slot cannot be represented precisely.", + "a2_expect": [ + { + "function": "ShapeParamsHandle.Caller", + "call": { + "callee": "ShapeParamsHandle.Sink", + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + } + ], + "measured_at": "P-037 A2.1 relevance/opacity fix in BuildGuardedFacts (this commit)", + "facts": { + "ShapeParamsHandle.Caller": { + "params": null, + "body": [ + "acquire:keep@18", + "release:keep@21" + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 20, + "column": 9 + }, + "statement_line": 20, + "form": "statement", + "callee": "ShapeParamsHandle.Sink", + "sig": "System.IO.Stream[]", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + ], + "guards": [] + } + } + }, + "verdict": { + "rust": [], + "python": [] + } +} diff --git a/corpus/p037-shapes/sidecar-relevance-refout-handle/case.cs b/corpus/p037-shapes/sidecar-relevance-refout-handle/case.cs new file mode 100644 index 00000000..9fdf262e --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-refout-handle/case.cs @@ -0,0 +1,23 @@ +// A tracked handle local passed by `ref` is unrepresentable precisely (the +// slot must be opaque), but it still flowed: the call record must exist, not +// vanish. Same relevance/representability separation as the `params` shape, +// via a different route Roslyn treats specially (RefKindKeyword, not a +// resolved `params` parameter). `keep` is a second, non-escaping local +// purely so the method still gets flow-analysed at all. +using System.IO; + +static class ShapeRefOutHandle +{ + static void Touch(ref Stream s) + { + } + + static void Caller(string path) + { + var keep = File.OpenRead(path); + var s = File.OpenRead(path); + Touch(ref s); + keep.Dispose(); + s.Dispose(); + } +} diff --git a/corpus/p037-shapes/sidecar-relevance-refout-handle/expected.json b/corpus/p037-shapes/sidecar-relevance-refout-handle/expected.json new file mode 100644 index 00000000..0b0ccb6e --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-refout-handle/expected.json @@ -0,0 +1,57 @@ +{ + "schema": "p037-fact-shape/1", + "shape": "sidecar-relevance-refout-handle", + "status": "anchored", + "why": "Regression for the same relevance/opacity coupling bug as sidecar-relevance-params-handle, via `ref` instead of `params`: a handle passed by `ref` is unrepresentable precisely (must be `opaque`), but the producer also zeroed the slot's HANDLE bit, so the whole call vanished from guarded_facts. NOTE (separate, pre-existing, not this fix's concern): `callee`/`sig`/`first_party` resolve to null/false here — Roslyn's `GetSymbolInfo` does not resolve the invoked method symbol when the sole argument is passed by `ref` in this extractor's single-file semantic-model context. That is an independent, narrower gap (callee identification for a `ref`-argument call) pinned here as observed fact, not something this shape's contract depends on.", + "a2_contract": "The call to a `ref`-taking sink stays in guarded_facts.calls[] with an opaque slot for the handle argument; it must not be silently dropped just because the slot cannot be represented precisely.", + "a2_expect": [ + { + "function": "ShapeRefOutHandle.Caller", + "call": { + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + } + ], + "measured_at": "P-037 A2.1 relevance/opacity fix in BuildGuardedFacts (this commit)", + "facts": { + "ShapeRefOutHandle.Caller": { + "params": null, + "body": [ + "acquire:keep@17", + "release:keep@20" + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 19, + "column": 9 + }, + "statement_line": 19, + "form": "statement", + "callee": null, + "sig": null, + "first_party": false, + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + ], + "guards": [] + } + } + }, + "verdict": { + "rust": [], + "python": [] + } +} diff --git a/corpus/p037-shapes/sidecar-relevance-unstable-owned/case.cs b/corpus/p037-shapes/sidecar-relevance-unstable-owned/case.cs new file mode 100644 index 00000000..b48328cf --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-unstable-owned/case.cs @@ -0,0 +1,22 @@ +// An owned parameter that fails the whole-body stability check (G-V4: it is +// reassigned somewhere in the method) is still an OWNED parameter — stability +// decides `param` vs `opaque` representation, per spec/OwnIR.md §5.2, it does +// not decide whether the call is relevant. The call record must exist with +// an opaque slot for `p`, not vanish because `p` happened to be unstable. +using System.IO; + +static class ShapeUnstableOwnedParam +{ + static void Sink(Stream s) + { + } + + static void Caller(Stream p, bool replace) + { + if (replace) + { + p = null; + } + Sink(p); + } +} diff --git a/corpus/p037-shapes/sidecar-relevance-unstable-owned/expected.json b/corpus/p037-shapes/sidecar-relevance-unstable-owned/expected.json new file mode 100644 index 00000000..96ac2173 --- /dev/null +++ b/corpus/p037-shapes/sidecar-relevance-unstable-owned/expected.json @@ -0,0 +1,73 @@ +{ + "schema": "p037-fact-shape/1", + "shape": "sidecar-relevance-unstable-owned", + "status": "anchored", + "why": "Regression for a relevance/opacity coupling bug in ArgFact: an owned parameter that fails the whole-body G-V4 stability check (here, `p` is conditionally reassigned) is still an OWNED parameter — stability decides `param` vs `opaque` representation, it does not decide whether the call is relevant. The producer zeroed the handle bit for any unstable owned parameter, so the whole call vanished from guarded_facts instead of surviving as an opaque-argument call.", + "a2_contract": "The call to a normal-argument sink stays in guarded_facts.calls[] with an opaque slot for the unstable owned parameter; it must not be silently dropped just because the parameter's value cannot be represented precisely.", + "a2_expect": [ + { + "function": "ShapeUnstableOwnedParam.Caller", + "call": { + "callee": "ShapeUnstableOwnedParam.Sink", + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + } + ], + "measured_at": "P-037 A2.1 relevance/opacity fix in BuildGuardedFacts (this commit)", + "facts": { + "ShapeUnstableOwnedParam.Caller": { + "params": [ + { + "name": "p", + "line": 14 + } + ], + "body": [ + "if:None@16", + "use:p@20" + ], + "guarded_facts": { + "version": 1, + "calls": [ + { + "site": { + "line": 20, + "column": 9 + }, + "statement_line": 20, + "form": "statement", + "callee": "ShapeUnstableOwnedParam.Sink", + "sig": "System.IO.Stream", + "first_party": true, + "args": [ + { + "param": 0, + "kind": "opaque" + } + ] + } + ], + "guards": [ + { + "site": { + "line": 16, + "column": 9 + }, + "param": 1, + "predicate": "truth", + "negated": false + } + ] + } + } + }, + "verdict": { + "rust": [], + "python": [] + } +} diff --git a/frontend/roslyn/OwnSharp.Extractor/Program.cs b/frontend/roslyn/OwnSharp.Extractor/Program.cs index 0e3d831f..7f6f0daf 100644 --- a/frontend/roslyn/OwnSharp.Extractor/Program.cs +++ b/frontend/roslyn/OwnSharp.Extractor/Program.cs @@ -2993,10 +2993,15 @@ bool Stable(IParameterSymbol p) case IdentifierNameSyntax id: if (OwnParam(id) is { } sp) { + // Relevance ("a tracked/owned handle syntactically flows here") and + // representability (how precisely we can encode the slot) are + // orthogonal: an unstable owned parameter is still owned, it is just + // opaque, so the handle bit must survive both branches. + var isOwned = ownedParamNames.Contains(sp.Name); if (!Stable(sp)) - return (new() { ["kind"] = "opaque" }, false); + return (new() { ["kind"] = "opaque" }, isOwned); return (new() { ["kind"] = "param", ["source_param"] = sp.Ordinal }, - ownedParamNames.Contains(sp.Name)); + isOwned); } if (model.GetSymbolInfo(id).Symbol is ILocalSymbol && handles.Contains(id.Identifier.Text)) @@ -3069,13 +3074,14 @@ void Bind(int ordinal, Dictionary fact, bool handle) ordinal = i; // unresolved callee: source position, and the record says so var refOrOut = args[i].RefKindKeyword.IsKind(SyntaxKind.RefKeyword) || args[i].RefKindKeyword.IsKind(SyntaxKind.OutKeyword); + // Evaluate the argument's handle-ness unconditionally: `ref`/`out`/`params` + // make the slot unrepresentable precisely (opaque), but a tracked handle + // passed that way still flowed into the call and must keep the call relevant. + var (af, ah) = ArgFact(args[i].Expression); if (refOrOut || bound is { IsParams: true }) - Bind(ordinal, new() { ["kind"] = "opaque" }, false); + Bind(ordinal, new() { ["kind"] = "opaque" }, ah); else - { - var (af, ah) = ArgFact(args[i].Expression); Bind(ordinal, af, ah); - } } if (!relevant) continue; From cd7e020757de32f8a74291a0b04201275e81568d Mon Sep 17 00:00:00 2001 From: PhysShell Date: Sat, 19 Sep 2026 07:18:24 +0000 Subject: [PATCH 3/3] docs(p037): record A2.1 zero-semantic-cut evidence at corrected A' MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Supersedes 2cbd6c6 (PR #362), whose source_commit (dce26ed) had the call-relevance bug fixed by the parent commit. Four after-takes (MOS repo, MOS corpus, verdict/python, verdict/rust) at A2.1 treatment commit 5a0de070af241a2612859153887ad6ae04afcce2, population held at terminal-green T (4a8e6582e10222403cd40adc9e95db7e0228a1c2), in the same preserved M1 measurement environment used for the T baseline. All four compare UNCHANGED against the R-recorded baseline: MOS repo facts_moved=1, MOS corpus facts_moved=36 (both counts unchanged from the pre-fix run — the fix's edge cases do not appear in this population), both verdict engines report no verdict moved. Evidence-only: no instrument, treatment, spec, or CI file touched; built directly on A', not rebased. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_011wKL9pEApQTK4dE3eXv8g8 --- docs/evidence/p037-a2.1-after-manifest.md | 70 + docs/evidence/p037-a2.1-after-mos-corpus.json | 7447 +++++++++++++++++ docs/evidence/p037-a2.1-after-mos-repo.json | 2672 ++++++ .../p037-a2.1-after-verdict-python.json | 1662 ++++ .../p037-a2.1-after-verdict-rust.json | 1709 ++++ 5 files changed, 13560 insertions(+) create mode 100644 docs/evidence/p037-a2.1-after-manifest.md create mode 100644 docs/evidence/p037-a2.1-after-mos-corpus.json create mode 100644 docs/evidence/p037-a2.1-after-mos-repo.json create mode 100644 docs/evidence/p037-a2.1-after-verdict-python.json create mode 100644 docs/evidence/p037-a2.1-after-verdict-rust.json diff --git a/docs/evidence/p037-a2.1-after-manifest.md b/docs/evidence/p037-a2.1-after-manifest.md new file mode 100644 index 00000000..00bc61c4 --- /dev/null +++ b/docs/evidence/p037-a2.1-after-manifest.md @@ -0,0 +1,70 @@ +# P-037 A2.1 zero-semantic-cut evidence (after-run at A', superseding the A run) + +T = `4a8e6582e10222403cd40adc9e95db7e0228a1c2` (terminal-green baseline commit) +R = `5fd6bfa6abd4c2af7e53712af300cf66c97f2f50` (baseline evidence commit, in + `main` via PR #361) +A = `dce26ed1f5d831e36f78f02e307b8b772c8a8800` (original A2.1 treatment: + emits the guarded-fact sidecar — SUPERSEDED, see below) +A' = `5a0de070af241a2612859153887ad6ae04afcce2` (A2.1 treatment, corrected: + decouples call RELEVANCE from argument REPRESENTABILITY in + `BuildGuardedFacts`; branch `claude/p037-a2.1-relevance-fix`, built + directly on A) +M = `P037_A2_MEASUREMENT_M1`, the same preserved measurement environment + used for the T baseline and the original A run; same workspace + checkout root reused, not a fresh worktree. + +## Why A' exists (A is not evidence-admissible) + +Independent review of the A run's after-evidence (`2cbd6c6`, PR #362, since +superseded) found a real contract bug in A's `BuildGuardedFacts`: a handle +argument that had to be encoded `opaque` (params/`ref`/`out`, or an unstable +owned parameter) also had its RELEVANCE bit zeroed, so the entire call +record silently vanished from `guarded_facts` instead of surviving with an +opaque slot — contradicting spec/OwnIR.md §5.2 ("an unstable parameter +argument becomes opaque, not absent"). A' fixes this and adds three +regression shapes (`corpus/p037-shapes/sidecar-relevance-*`), each verified +against the pre-fix code first (reproduced the bug) and the fix (call +record now present). See A''s commit message for the full analysis. + +Per the reviewer's explicit rule and general P-037 discipline: A is not +rewritten (its SHA is retired, not reused) — A' is a new commit, and this +evidence commit (S') truthfully names A' as its `source_commit`. The prior +S (`2cbd6c6`, PR #362) is stale and should not be merged; this commit +replaces it. + +## Four after-takes at A', population held at T + +| artifact | sha256 | compare result | +|---|---|---| +| p037-a2.1-after-mos-repo.json | `c9a06af959252f7c3c54bc239eef7249987e73c9ccd21357b11c1ab0fb4911f9` | UNCHANGED, facts_moved=1, python_mos_moved=0, rust_mos_moved=0, after_parity_moved=0 | +| p037-a2.1-after-mos-corpus.json | `6d9ca1f60217483c0544000977aabfd72e9edbd4159e6e081f9fb57075e04e5f` | UNCHANGED, facts_moved=36, python_mos_moved=0, rust_mos_moved=0, after_parity_moved=0 | +| p037-a2.1-after-verdict-python.json | `2d6e673fed1bd2fe3c71ef86047f51a5fafe1e691f7cdca1292482eda348183f` | UNCHANGED, no verdict moved (137 files, level=verdict) | +| p037-a2.1-after-verdict-rust.json | `9d2166acdad693a6742c1e90130a7dc679d1ad49eac80c1a5efa28e0460eceab` | UNCHANGED, no verdict moved (137 files, level=verdict); own-cli qualified sha == executed sha (`8373f5f5...`, unchanged from T — the fix is C#-only), post_run_intact=true | + +`facts_moved` counts (1 and 36) are identical to the original (buggy) A run: +neither the repo's own 81 files nor the 137-file corpus happen to contain a +`params`/`ref`/`out` disposable-handle argument or an unstable owned +parameter, so the relevance fix does not change either fact-diff count here +— it is a correctness fix visible on the three new regression shapes, not +on this measured population. That is an observation, not a pre-registered +predicate. + +Compared against the same T-baseline artifacts recorded in R (unchanged +from the prior comparison). All four: `is_evidence=true`, +`source_commit=A'`, `population_commit=T`, `dirty=false`, +`post_run_population_intact=true`. + +## Execution profile equality + +`p037_evidence.py profile` output is byte-identical to the T-baseline +capture: CPython 3.11.15, .NET SDK 8.0.425 (runtimes +Microsoft.AspNetCore.App 8.0.31 + Microsoft.NETCore.App 8.0.31), +rustc/cargo 1.94.1. + +## Known pre-existing observation (not fixed here) + +`scope_cache_sites[].file` in the raw facts carries an absolute path +rather than a repo-relative one — a pre-existing portability defect from +T, not introduced by A or A'. Unaffected by this evidence-only commit. + +Taken: 2026-09-19 (UTC), operator run. diff --git a/docs/evidence/p037-a2.1-after-mos-corpus.json b/docs/evidence/p037-a2.1-after-mos-corpus.json new file mode 100644 index 00000000..9bc025a4 --- /dev/null +++ b/docs/evidence/p037-a2.1-after-mos-corpus.json @@ -0,0 +1,7447 @@ +{ + "analysis_manifest": [ + { + "blob": "38d180096c63c7d01d7bb39601c1f88e3a53f67e", + "path": "corpus/di/singleton-captures-scoped-dbcontext/after.cs" + }, + { + "blob": "4d6f60e065d7e2572bc457e3df6a593b6a4699c4", + "path": "corpus/di/singleton-captures-scoped-dbcontext/before.cs" + }, + { + "blob": "67c4aa0b15fa0782d865cbd1c5ef355fbc926f8f", + "path": "corpus/fixtures/systemevents-console/Program.cs" + }, + { + "blob": "c9d140949acfe06bd187404508a46b6b61a7c89e", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/after.cs" + }, + { + "blob": "c80dee0bc66037c3c4ae7ff8ce8125ba145f8156", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/before.cs" + }, + { + "blob": "b13ab3891e11f2281754d5c5664fc92bc97710c5", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs" + }, + { + "blob": "482151f9ed085819fc82bbe85df003beec21ed02", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs" + }, + { + "blob": "b60e95a076611d3661fef95091f041ba228d546e", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs" + }, + { + "blob": "b93a52759704651ccb7d09d946c0900c8ab46e54", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs" + }, + { + "blob": "48b0accda29b02366d4f652b5c05c2ee7956f6d2", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs" + }, + { + "blob": "77cc02f8920b8ac424dd0854d2a1ec188329a01b", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs" + }, + { + "blob": "0d862db009407131da16a23b1cc255d3155a64b2", + "path": "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs" + }, + { + "blob": "28a89ec5ee3eb48673ec895f3bd0f8404ec29e99", + "path": "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs" + }, + { + "blob": "faf7be2c04decc1a966a5870e0641ec47d72da5c", + "path": "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs" + }, + { + "blob": "87f06ebe8d6842ec1011a0c8e935c92fd47ee714", + "path": "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs" + }, + { + "blob": "1faa3a7b8fa19ae08128e1b1f30d6dfae1e9f534", + "path": "corpus/real-world/ado-executereader-leak/after.cs" + }, + { + "blob": "d69020eceb2c3619ce3d2f6f36715d97aad5b616", + "path": "corpus/real-world/ado-executereader-leak/before.cs" + }, + { + "blob": "d36d794ecd78e95a99964ecd5ff4e66cc1352e43", + "path": "corpus/real-world/arraypool-aliased-receiver/after.cs" + }, + { + "blob": "3ee0cbfd662aec91a0c437ade04ef9f5a885280a", + "path": "corpus/real-world/arraypool-aliased-receiver/before.cs" + }, + { + "blob": "9c319b50c8147b72a07f2c4c643c936d9849e35c", + "path": "corpus/real-world/arraypool-double-return/after.cs" + }, + { + "blob": "9dc6c22a359a922ea104e2babd1f6c3cb18c55aa", + "path": "corpus/real-world/arraypool-double-return/before.cs" + }, + { + "blob": "fa9fce58d4d9f62a37ab0cd5b88b49627b6e2553", + "path": "corpus/real-world/arraypool-field-fullspan-overread/after.cs" + }, + { + "blob": "768af16266ec428afdb343185a654138d1d04d71", + "path": "corpus/real-world/arraypool-field-fullspan-overread/before.cs" + }, + { + "blob": "3c45a05482eae50f6c68f806e80e1bd030f30151", + "path": "corpus/real-world/arraypool-fullspan-overread/after.cs" + }, + { + "blob": "991b898ca1f564320ee3f5b9eba69e56b5607f6d", + "path": "corpus/real-world/arraypool-fullspan-overread/before.cs" + }, + { + "blob": "8f1c0de961065338fa611e1ac2b3e93099d1a390", + "path": "corpus/real-world/arraypool-length-overread/after.cs" + }, + { + "blob": "0c7d64c1159b4041118b674a912a7f5533e8a301", + "path": "corpus/real-world/arraypool-length-overread/before.cs" + }, + { + "blob": "8c8794e57d810cd542d90c12cea06ff1c034a0fc", + "path": "corpus/real-world/arraypool-memory-view-escape/after.cs" + }, + { + "blob": "7a29e26ef81bc82f98b5c19f626ead25de43986e", + "path": "corpus/real-world/arraypool-memory-view-escape/before.cs" + }, + { + "blob": "debff6f8435c5f396cd1b00d9c12cf09102d13f9", + "path": "corpus/real-world/arraypool-span-view-after-return/after.cs" + }, + { + "blob": "818d3c8cba0b5dbcc9cec5993322d2e04c840f17", + "path": "corpus/real-world/arraypool-span-view-after-return/before.cs" + }, + { + "blob": "708735216525a12901b06cce249aa65f37b5da6b", + "path": "corpus/real-world/arraypool-use-after-return/after.cs" + }, + { + "blob": "0506cd9adcf09ac17e98c56d713d33b516a791af", + "path": "corpus/real-world/arraypool-use-after-return/before.cs" + }, + { + "blob": "6ec2e76f1070f5a1fa3942e11f7e5e5009fe7a03", + "path": "corpus/real-world/arraypool-view-into-field-overread/after.cs" + }, + { + "blob": "5c72fc7284fec7a262a66a499e3197cc663771ac", + "path": "corpus/real-world/arraypool-view-into-field-overread/before.cs" + }, + { + "blob": "02e54d36919c8d03bce56321faa1f7efabb981f9", + "path": "corpus/real-world/field-dispose-via-exchange/after.cs" + }, + { + "blob": "b532135df2f7946e70829834444059b840a168f5", + "path": "corpus/real-world/field-dispose-via-exchange/before.cs" + }, + { + "blob": "c9b071d49cbddd567a108425de4cd7803886b1c6", + "path": "corpus/real-world/field-dispose-via-helper/after.cs" + }, + { + "blob": "7d232b848ef85fbb55deafaff024084a857d7edd", + "path": "corpus/real-world/field-dispose-via-helper/before.cs" + }, + { + "blob": "a07539757bc6bf6ae24766092f56f72ca7bf3010", + "path": "corpus/real-world/field-noop-dispose-wrapper/after.cs" + }, + { + "blob": "8fd5c820e25bab6682f5b02e43b562d2305410a3", + "path": "corpus/real-world/field-noop-dispose-wrapper/before.cs" + }, + { + "blob": "135a360400f5da99bcf6ba5a2efcd1413833e868", + "path": "corpus/real-world/local-dispose-via-using-statement/after.cs" + }, + { + "blob": "5c93e81a1c4bc7b43fd9493a73d2227926d6c069", + "path": "corpus/real-world/local-dispose-via-using-statement/before.cs" + }, + { + "blob": "c7d52d6ead47c013d221e5a3406b98044ced70a2", + "path": "corpus/real-world/memorypool-double-dispose/after.cs" + }, + { + "blob": "b0a3acd9dced8ea7f2bb4702e92984e2be53f931", + "path": "corpus/real-world/memorypool-double-dispose/before.cs" + }, + { + "blob": "51f5e21473f3831892c82e8b35277dc91108bdcf", + "path": "corpus/real-world/memorypool-using-owner-escape/after.cs" + }, + { + "blob": "bfc1b768c48074d67f7da744a2cfd1e58b77be06", + "path": "corpus/real-world/memorypool-using-owner-escape/before.cs" + }, + { + "blob": "2466da9d86248686070994b434beca526c51fe06", + "path": "corpus/real-world/memorypool-using-statement-view-escape/after.cs" + }, + { + "blob": "afc9ea74b3e8c407c06d7a797ba3673a926f5c3c", + "path": "corpus/real-world/memorypool-using-statement-view-escape/before.cs" + }, + { + "blob": "499ce51f09325341ddbbb8236944fa9bc2158eac", + "path": "corpus/real-world/memorypool-using-view-escape/after.cs" + }, + { + "blob": "45437c15fa6ec4e2b5f28f16cfc41155866f00ae", + "path": "corpus/real-world/memorypool-using-view-escape/before.cs" + }, + { + "blob": "7327ffa1666b4ba534fbb9a3f0d5f9d4a9e1b628", + "path": "corpus/real-world/memorypool-view-after-dispose/after.cs" + }, + { + "blob": "072dfa923df7e919913fc69e0d676e5ce2ebafa5", + "path": "corpus/real-world/memorypool-view-after-dispose/before.cs" + }, + { + "blob": "78eb173af727d40d4477ebb313cfcbf5291068c2", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs" + }, + { + "blob": "a4deffc410b2dedfc5edb61cec3ef6f1777d0adf", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs" + }, + { + "blob": "f2a81599a30d95c539b3918aeef3d4213e50c721", + "path": "corpus/real-world/ownership-handoff-consume/after.cs" + }, + { + "blob": "d65ba7b9424e36eb2c5e7e8fc7b390bdb2f6bfff", + "path": "corpus/real-world/ownership-handoff-consume/before.cs" + }, + { + "blob": "91134e9bd2cc709b0174e20c31e43b76b297df66", + "path": "corpus/real-world/ownership-handoff-use-transitive/after.cs" + }, + { + "blob": "2ed2ca15dfdea27d0f1a072d3b569eea7596b0b1", + "path": "corpus/real-world/ownership-handoff-use-transitive/before.cs" + }, + { + "blob": "8aacb78586d8441ea060a6fcac1590bb7c4e824e", + "path": "corpus/real-world/ownership-handoff-use/after.cs" + }, + { + "blob": "e4a61bf6023f4e32f54a1c4887e26c844f757f42", + "path": "corpus/real-world/ownership-handoff-use/before.cs" + }, + { + "blob": "a4f71bc85fc6219e309a7ffb2fe4659c7ba647cd", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/after.cs" + }, + { + "blob": "004dfda6385ff8697c8c16aeb844bcfb46ca9a2a", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/before.cs" + }, + { + "blob": "48fea235d362012f5482abbe598a69ba513f598a", + "path": "corpus/real-world/screentogif-loaded-subscription/after.cs" + }, + { + "blob": "f531ea536868381417fef0d8392bf956802ea194", + "path": "corpus/real-world/screentogif-loaded-subscription/before.cs" + }, + { + "blob": "f353a95c721347d12317acd7ea4b089495c9ec1a", + "path": "corpus/real-world/screentogif-systemevents-leak/after.cs" + }, + { + "blob": "f531e57e99f32029d1ae7b3df183c2785ef85714", + "path": "corpus/real-world/screentogif-systemevents-leak/before.cs" + }, + { + "blob": "671e8c665df0f4a951fd14002b056355b37019ea", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs" + }, + { + "blob": "09dbfd123416af89eff3f8e301ec300f184a2d8d", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs" + }, + { + "blob": "37eabf992f0e083364d20160a1ddf0c82c28b768", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs" + }, + { + "blob": "2355f37e9fc8fc6b63e5023a2a2a18265b16d669", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs" + }, + { + "blob": "74a99ffd338ef3cbf853cf2804c3a3ece8ed42a7", + "path": "corpus/real-world/socket-accept-leak/after.cs" + }, + { + "blob": "18a721ce6d07b7eed6cf97afef578d97e7ba2744", + "path": "corpus/real-world/socket-accept-leak/before.cs" + }, + { + "blob": "3be8156197c7e76fe60eee06028c65fe03407254", + "path": "corpus/real-world/subscription-self-owned-property/after.cs" + }, + { + "blob": "53ec5ba89ca9eb3791bcc7c2489c5884dd0acad7", + "path": "corpus/real-world/subscription-self-owned-property/before.cs" + }, + { + "blob": "601976e5600d97d6184fe5dc44b957c985a97115", + "path": "corpus/real-world/tcplistener-accept-leak/after.cs" + }, + { + "blob": "ab88672d4e90e99b7a8fb2a061d533a5a5ef0072", + "path": "corpus/real-world/tcplistener-accept-leak/before.cs" + }, + { + "blob": "dce3d96a463068f59288176541d5c75befa570b8", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/after.cs" + }, + { + "blob": "6ae9c4c8faef9559b9ac4de4da1ba03c4acada5e", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/before.cs" + }, + { + "blob": "b54a2b87b1f584a9a857c5f311d5874099910643", + "path": "corpus/real-world/using-statement-throw-releases/after.cs" + }, + { + "blob": "acc415ddf95c058de642d3a13e39226570ebf6e0", + "path": "corpus/real-world/using-statement-throw-releases/before.cs" + }, + { + "blob": "ef464e6cf0f0bb0c9d3941fa0fce881b78011bcb", + "path": "corpus/wpf/custom-weak-wrapper/after.cs" + }, + { + "blob": "d255613e1dbf311f93c34cbabc1ae304b648ea2b", + "path": "corpus/wpf/custom-weak-wrapper/before.cs" + }, + { + "blob": "30697c7b21435ea03352b9f1826938c88a60d3d9", + "path": "corpus/wpf/field-use-after-dispose/after.cs" + }, + { + "blob": "79fdb97a6375c5b1b6df5be6967bd22c738e9cce", + "path": "corpus/wpf/field-use-after-dispose/before.cs" + }, + { + "blob": "242fec8ebaf85ea83df4a0a27c9f1e6cac80a9b8", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs" + }, + { + "blob": "445968e5bc0d6bb77950196774b5f645c6d56459", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs" + }, + { + "blob": "2aaf3b53fba9dd98a72cbe7c2caed65cf89262fd", + "path": "corpus/wpf/handler-use-after-dispose/after.cs" + }, + { + "blob": "68e25c6b763c122df627b3e7847f548524db9d21", + "path": "corpus/wpf/handler-use-after-dispose/before.cs" + }, + { + "blob": "b62ced3b658f10929e98d5fca7c65401b4fc0aea", + "path": "corpus/wpf/pooled-view-after-dispose/after.cs" + }, + { + "blob": "4731249cfee1b47a750fbc11ac66b598b17453ae", + "path": "corpus/wpf/pooled-view-after-dispose/before.cs" + }, + { + "blob": "9b093f5e39f7087333b7f8f2c89a4b155e078edd", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs" + }, + { + "blob": "e7d5904e1c32d78a267309faf6717be59a374aec", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs" + }, + { + "blob": "cb3ed69a917c9516ddcafa5c7c55cc8467739fe5", + "path": "corpus/wpf/subscription-disposing-else-branch-release/after.cs" + }, + { + "blob": "d0e1dc7929300bc60f4349a7e0df29ca87d018ce", + "path": "corpus/wpf/subscription-disposing-else-branch-release/before.cs" + }, + { + "blob": "bae861a35a441a2fc7714d9904883bd576182ed4", + "path": "corpus/wpf/subscription-explicit-delegate-release/after.cs" + }, + { + "blob": "e86bb4d5ff49116c6fd49c045b7d4f5136add534", + "path": "corpus/wpf/subscription-explicit-delegate-release/before.cs" + }, + { + "blob": "8299b26e3d1d9ec7c15673ba148199aafac6c6ef", + "path": "corpus/wpf/subscription-finalizer-release/after.cs" + }, + { + "blob": "3d03e2c90b8c8cacd68ef93cf44587f3d299288d", + "path": "corpus/wpf/subscription-finalizer-release/before.cs" + }, + { + "blob": "622e8cd997b9d2acf731c3b415166568339adf3a", + "path": "corpus/wpf/subscription-nonteardown-release/after.cs" + }, + { + "blob": "54f7969790b8daa82b498f795e1341e63fc1dd89", + "path": "corpus/wpf/subscription-nonteardown-release/before.cs" + }, + { + "blob": "934577f5c5c294d77029d816908b69f276c6583c", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/after.cs" + }, + { + "blob": "1a0462ebd958a6e7d1a23dae2b8c99a1fdf48700", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/before.cs" + }, + { + "blob": "b1b9faf7f5ce931bc89316e239ec03b482cc6700", + "path": "corpus/wpf/subscription-param-guarded-unregister/after.cs" + }, + { + "blob": "015343c46671afe384fd1a60d38c107426a01420", + "path": "corpus/wpf/subscription-param-guarded-unregister/before.cs" + }, + { + "blob": "f57d5340e25a55538de23892e29c1718d3042e8f", + "path": "corpus/wpf/subscription-target-typed-delegate-release/after.cs" + }, + { + "blob": "b6ada87556cf82ab68f6c58afdfec9d85daa93ef", + "path": "corpus/wpf/subscription-target-typed-delegate-release/before.cs" + }, + { + "blob": "0cab64b233266ef06e6988f27326eded395271e3", + "path": "corpus/wpf/subscription-teardown-early-return-guard/after.cs" + }, + { + "blob": "85d32821de0a02990a5e1abf87eccc986bac6b93", + "path": "corpus/wpf/subscription-teardown-early-return-guard/before.cs" + }, + { + "blob": "23bd620a57b1a68d0cf6569125817caf3fb47efc", + "path": "corpus/wpf/subscription-uncalled-local-function/after.cs" + }, + { + "blob": "2e129b6bb1e183443a073bf083a3a04b844d9a98", + "path": "corpus/wpf/subscription-uncalled-local-function/before.cs" + }, + { + "blob": "292c674a95a34ddff1f9eace96bbd316dabafff5", + "path": "corpus/wpf/subscription-xaml-name-only-release/after.cs" + }, + { + "blob": "59c8548878d13a026de9ddc65534b38ae94f8864", + "path": "corpus/wpf/subscription-xaml-name-only-release/before.cs" + }, + { + "blob": "3062b7e371fb709c622ef5ac918f4682df990b3b", + "path": "corpus/wpf/systemevents-region-escape/after.cs" + }, + { + "blob": "5a89237790ae5b12d64a680288196c6ead8c6662", + "path": "corpus/wpf/systemevents-region-escape/before.cs" + }, + { + "blob": "4ab388af8e8ea1b1faaf154f0f878db498fce704", + "path": "corpus/wpf/timer-stop-disposing-else-branch/after.cs" + }, + { + "blob": "5c1a7e991a861b316bf08869ef425583d26da556", + "path": "corpus/wpf/timer-stop-disposing-else-branch/before.cs" + }, + { + "blob": "a8a4d710a2f06c25e43a106c1410800369696d74", + "path": "corpus/wpf/timer-stop-early-return-guard/after.cs" + }, + { + "blob": "2e8e5e241d7980c65a70857fa128400c23331fed", + "path": "corpus/wpf/timer-stop-early-return-guard/before.cs" + }, + { + "blob": "743a4fab56737068377dbc553a030cc87273a465", + "path": "corpus/wpf/timer-stop-finalizer-release/after.cs" + }, + { + "blob": "973df1396ee32098c045e55dff973b979f13c1fc", + "path": "corpus/wpf/timer-stop-finalizer-release/before.cs" + }, + { + "blob": "d8e77d9849476e5491b4dcc19a9e53e48ff39795", + "path": "corpus/wpf/timer-stop-nonteardown-release/after.cs" + }, + { + "blob": "a2b1699fa2ce74a8bfab34c8d63a2374a9696723", + "path": "corpus/wpf/timer-stop-nonteardown-release/before.cs" + }, + { + "blob": "d59b693ecf990fd43d60a1051544f40e1ad2c818", + "path": "corpus/wpf/timer-stop-param-guarded/after.cs" + }, + { + "blob": "012854a1e19f04133dc78ecbbd14a1cef8044622", + "path": "corpus/wpf/timer-stop-param-guarded/before.cs" + }, + { + "blob": "e76351d486fd80e1037a4bca2ab9783c7ae4c1fd", + "path": "corpus/wpf/timer-stop-uncalled-helper/after.cs" + }, + { + "blob": "42a743ff9743fd38551eaf687b0a96ac874f0eb8", + "path": "corpus/wpf/timer-stop-uncalled-helper/before.cs" + }, + { + "blob": "0a65c2215f03fc979d71d4f91458043e2b02a143", + "path": "corpus/wpf/timer-stop-uncalled-lambda/after.cs" + }, + { + "blob": "3c29d5f0fe3f49b79244fd482e18bc9a39b1bb52", + "path": "corpus/wpf/timer-stop-uncalled-lambda/before.cs" + }, + { + "blob": "39bef7650422dfbac6319adbf0a82a99105a9ee6", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/after.cs" + }, + { + "blob": "0d5062f2477f382150b32b286aa8726e51170200", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/before.cs" + }, + { + "blob": "b2b6b657b0da7947086911cd2833278e1ca926c2", + "path": "corpus/wpf/timer-stop-wrong-receiver/after.cs" + }, + { + "blob": "d781717509873e414e92801419decddb32e0f826", + "path": "corpus/wpf/timer-stop-wrong-receiver/before.cs" + }, + { + "blob": "82f57d8b91534fd08c54f1b1f0857c3f8c76d46e", + "path": "corpus/wpf/viewmodel-escapes-to-app/after.cs" + }, + { + "blob": "ae52b324a6e428015fc5974bd11d60f8bfe3e4d0", + "path": "corpus/wpf/viewmodel-escapes-to-app/before.cs" + }, + { + "blob": "1f96bb7c57b978ff329761ca730a7d975b39fba9", + "path": "corpus/wpf/zombie-viewmodel/after.cs" + }, + { + "blob": "e9e4d0700a5abff8114dbe619993069b05bd6fc2", + "path": "corpus/wpf/zombie-viewmodel/before.cs" + } + ], + "analysis_manifest_sha256": "97ea59f4b4e7409597cdc00bf0e7d6496397b5c24f8c7785a063c507a23d5397", + "artifacts": { + "own-shadow-engine": { + "binary": "own-shadow-engine", + "bytes": 1819088, + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "cargo_argv": [ + "cargo", + "build", + "--locked", + "--release", + "--message-format=json", + "-p", + "own-shadow", + "--bin", + "own-shadow-engine" + ], + "cargo_clean_argv": [ + "cargo", + "clean", + "--release", + "-p", + "own-shadow" + ], + "cargo_lock_blob": "d8adbb1dc4d90da0c80aa1a2d8ba85bef805620f", + "cargo_lock_sha256": "17553420691d96febcfac54bd8f530b4f9e2a1ad7c79e6aaa022510e56692f45", + "dirty": false, + "executable": "/home/tandem/cargo-target/release/own-shadow-engine", + "executed": { + "bytes": 1819088, + "post_run_intact": true, + "sealed_path": "/home/tandem/owen-p037-a2/tmp/p037-take-mcxokedb/own-shadow-engine", + "sha256": "21a311088337be0875d8803a51ce1be726bba5a5efe672359ed9dfdb8511e210" + }, + "host": "x86_64-unknown-linux-gnu", + "package": "own-shadow", + "profile": "release", + "rebuilt_by_this_call": true, + "repo_path": null, + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8", + "sha256": "21a311088337be0875d8803a51ce1be726bba5a5efe672359ed9dfdb8511e210", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2" + } + }, + "dirty": false, + "documents": { + "corpus/di/singleton-captures-scoped-dbcontext/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1536, + "digest": "85c82a5fa0ac836f0b0e1f8455dc8c7cf61a2c85bed3cbdefea2dfa91823428d" + }, + "inputs": [ + "corpus/di/singleton-captures-scoped-dbcontext/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/di/singleton-captures-scoped-dbcontext/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1532, + "digest": "345a702c503995c1d8b8dba4e4cfebf0b5bc707e12474267f5bc24c86be75616" + }, + "inputs": [ + "corpus/di/singleton-captures-scoped-dbcontext/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/fixtures/systemevents-console/Program.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2682, + "digest": "e543c101d7dacc8b396034c85e3bdc15b41c3fbea6ca671f9f7f939c7b1db31a" + }, + "inputs": [ + "corpus/fixtures/systemevents-console/Program.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.DisposeOnThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.LeakAFile", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.LeakInTry", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.DisposeOnThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.LeakAFile", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/fixtures/systemevents-console/Program.cs", + "line": 0, + "method": "SystemEventsLeak.Program.LeakInTry", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-early-return/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2511, + "digest": "30b2b462fcbffcdbf3b748b86c71fb15a51a0b2aad53bc520ba721e67bc8730d" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-early-return/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/after.cs", + "line": 0, + "method": "GuardedEarlyReturn.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/after.cs", + "line": 0, + "method": "GuardedEarlyReturn.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/after.cs", + "line": 0, + "method": "GuardedEarlyReturn.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/after.cs", + "line": 0, + "method": "GuardedEarlyReturn.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-early-return/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2512, + "digest": "2cb0a9694659e867278ddf08b9959033523c57d1ae3bef0d3720e8ef10f0f164" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-early-return/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/before.cs", + "line": 0, + "method": "GuardedEarlyReturn.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/before.cs", + "line": 0, + "method": "GuardedEarlyReturn.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/before.cs", + "line": 0, + "method": "GuardedEarlyReturn.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-early-return/before.cs", + "line": 0, + "method": "GuardedEarlyReturn.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2384, + "digest": "79a26622191c0b82aaa383a9e1b7aa9b96411e6c18e7f309422fff80904658c9" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs", + "line": 0, + "method": "Guarded.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs", + "line": 0, + "method": "Guarded.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2386, + "digest": "0abed21ffd9611f183835b2ad3299df7deded4bf7b64b85bfdfacab0b5c077f1" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs", + "line": 0, + "method": "Guarded.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs", + "line": 0, + "method": "Guarded.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3621, + "digest": "2a6a189b314dee1060b4056b07ed77c4ebd5d351f7defbcaae94765bc68d4c12" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs", + "line": 0, + "method": "GuardedNegation.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3625, + "digest": "5b813a08078fe69dc9835f366403519c0c2e4bc66c013c66fa872ad50e59186d" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs", + "line": 0, + "method": "GuardedNegation.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3581, + "digest": "f53037b8e7ca484d41527d4aaf27f6566be40c07e17aa7f06db62574df9cca62" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Fine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs", + "line": 0, + "method": "GuardedWrapper.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3583, + "digest": "32013f41e64b57a95e784efebac06f74181d6cce5a4b94f1bfd6b19046a8b802" + }, + "inputs": [ + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs", + "line": 0, + "method": "GuardedWrapper.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2429, + "digest": "ba19a76fa6f12c288478e1d2f7d37edc2ba2ccf4c4027dd8a0000aab257282dd" + }, + "inputs": [ + "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "q", + "transfer": "may" + }, + { + "disposable": true, + "index": 1, + "name": "r", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs", + "line": 0, + "method": "Guarded.Close", + "params": [ + { + "disposable": true, + "index": 0, + "name": "q", + "transfer": "may" + }, + { + "disposable": true, + "index": 1, + "name": "r", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3435, + "digest": "b8c0b96c638b18b0bd77a4e19face18b8eede7986d9ae77a2d219cc9b26ecfa6" + }, + "inputs": [ + "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3441, + "digest": "1ffcaab19bf8afadc3b68142dd667be60ddf9971be0fcd48aa5cc44c5c28c706" + }, + "inputs": [ + "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Outer", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2996, + "digest": "96ab1f78e3d4208b8281726591d9ad68627b9068504ea5ee9c1890ddca71daf7" + }, + "inputs": [ + "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs", + "line": 0, + "method": "Guarded.M", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs", + "line": 0, + "method": "Guarded.M", + "params": [ + { + "disposable": true, + "index": 0, + "name": "p", + "transfer": "may" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs", + "line": 0, + "method": "Guarded.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ado-executereader-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 753, + "digest": "98dd55d8d7d333293b09666f5646320c99e6df0314eb6b37c33367daed93edbf" + }, + "inputs": [ + "corpus/real-world/ado-executereader-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ado-executereader-leak/after.cs", + "line": 0, + "method": "AdoReaderLeak.Run", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cmd", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ado-executereader-leak/after.cs", + "line": 0, + "method": "AdoReaderLeak.Run", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cmd", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ado-executereader-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 906, + "digest": "dccd453dbb0343d6da461113a0d6ed3f52e8bb20c801e425648ed571590cba32" + }, + "inputs": [ + "corpus/real-world/ado-executereader-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ado-executereader-leak/before.cs", + "line": 0, + "method": "AdoReaderLeak.Run", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cmd", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ado-executereader-leak/before.cs", + "line": 0, + "method": "AdoReaderLeak.Run", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cmd", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-aliased-receiver/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2211, + "digest": "7446cb2b883a155a6a2525fe5535ead0c4a9c0ee7796efacbac777668db8be08" + }, + "inputs": [ + "corpus/real-world/arraypool-aliased-receiver/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-aliased-receiver/after.cs", + "line": 0, + "method": "PoolAliasedReceiver.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-aliased-receiver/after.cs", + "line": 0, + "method": "PoolAliasedReceiver.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-aliased-receiver/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3142, + "digest": "c5510febcde9faa66d75f4f98e431455d4883c33e74d87fe9fd953d9bb2b8d4a" + }, + "inputs": [ + "corpus/real-world/arraypool-aliased-receiver/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-aliased-receiver/before.cs", + "line": 0, + "method": "PoolAliasedReceiver.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-aliased-receiver/before.cs", + "line": 0, + "method": "PoolAliasedReceiver.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-double-return/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2201, + "digest": "a479cd632feedc81bde5e3e9bdc1af17c52535ceaf5b55dc7675ce7a915a2d6a" + }, + "inputs": [ + "corpus/real-world/arraypool-double-return/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-double-return/after.cs", + "line": 0, + "method": "PoolDoubleReturn.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-double-return/after.cs", + "line": 0, + "method": "PoolDoubleReturn.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-double-return/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3133, + "digest": "fecf8318dda52c8224fa5a7f7998f0649d28794e428848d38b9539c4b37f7e4c" + }, + "inputs": [ + "corpus/real-world/arraypool-double-return/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-double-return/before.cs", + "line": 0, + "method": "PoolDoubleReturn.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-double-return/before.cs", + "line": 0, + "method": "PoolDoubleReturn.Use", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-field-fullspan-overread/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 605, + "digest": "5c21a85b91520a438eb205825184e84b0bf2ed651ccb8a08142fc139fefeb8c2" + }, + "inputs": [ + "corpus/real-world/arraypool-field-fullspan-overread/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-field-fullspan-overread/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1739, + "digest": "d5c207545b80313cae61bde69bb4f08c1ede589b15d234ff840cfe434a495fd4" + }, + "inputs": [ + "corpus/real-world/arraypool-field-fullspan-overread/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-field-fullspan-overread/before.cs", + "line": 0, + "method": "FieldPoolFramer.Flush", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-field-fullspan-overread/before.cs", + "line": 0, + "method": "FieldPoolFramer.FlushMeta", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-field-fullspan-overread/before.cs", + "line": 0, + "method": "FieldPoolFramer.Flush", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-field-fullspan-overread/before.cs", + "line": 0, + "method": "FieldPoolFramer.FlushMeta", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-fullspan-overread/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3583, + "digest": "41a11c17a358e37677fb02464a897ac22317265a6e15c95190da6e26e4ed4042" + }, + "inputs": [ + "corpus/real-world/arraypool-fullspan-overread/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-fullspan-overread/after.cs", + "line": 0, + "method": "PoolFullSpanOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-fullspan-overread/after.cs", + "line": 0, + "method": "PoolFullSpanOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-fullspan-overread/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3276, + "digest": "486a5546cfefb8cb3d711173c2b9188827a227df4d6fa5c74c5b556042696c94" + }, + "inputs": [ + "corpus/real-world/arraypool-fullspan-overread/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-fullspan-overread/before.cs", + "line": 0, + "method": "PoolFullSpanOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-fullspan-overread/before.cs", + "line": 0, + "method": "PoolFullSpanOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-length-overread/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2782, + "digest": "4c07a47b3c61a242d824bb679a78cc9fbeb250f1429a6f9d8e20ef579bc57336" + }, + "inputs": [ + "corpus/real-world/arraypool-length-overread/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-length-overread/after.cs", + "line": 0, + "method": "PoolLengthOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-length-overread/after.cs", + "line": 0, + "method": "PoolLengthOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-length-overread/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2843, + "digest": "50cfd7c2345bcf077bd388680265b1018f537681c8fde98891b7f8cad159d300" + }, + "inputs": [ + "corpus/real-world/arraypool-length-overread/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-length-overread/before.cs", + "line": 0, + "method": "PoolLengthOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-length-overread/before.cs", + "line": 0, + "method": "PoolLengthOverread.Frame", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-memory-view-escape/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2287, + "digest": "252224138acac2dcf05f36cab40dc1e11e3eaabc50b98a8ccb6cbb71e24a93e9" + }, + "inputs": [ + "corpus/real-world/arraypool-memory-view-escape/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-memory-view-escape/after.cs", + "line": 0, + "method": "PoolMemoryViewEscape.Render", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-memory-view-escape/after.cs", + "line": 0, + "method": "PoolMemoryViewEscape.Render", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-memory-view-escape/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2722, + "digest": "4cc111ee1bb3c8fd4f71ec85ccbeffd1cba83c903efa13c592cb2881a4fbb4be" + }, + "inputs": [ + "corpus/real-world/arraypool-memory-view-escape/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-memory-view-escape/before.cs", + "line": 0, + "method": "PoolMemoryViewEscape.Render", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-memory-view-escape/before.cs", + "line": 0, + "method": "PoolMemoryViewEscape.Render", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-span-view-after-return/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2112, + "digest": "a4daaab72b60c83816d8dc8213fe0aa6b168e3b05fc2a6096866d50b3cf220b4" + }, + "inputs": [ + "corpus/real-world/arraypool-span-view-after-return/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-span-view-after-return/after.cs", + "line": 0, + "method": "PoolSpanViewAfterReturn.Scramble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-span-view-after-return/after.cs", + "line": 0, + "method": "PoolSpanViewAfterReturn.Scramble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-span-view-after-return/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2113, + "digest": "3d52cfbd5796fb6d8cb98b98ca167548a1f2cbc319b8cbbd9ec9e2b675619d40" + }, + "inputs": [ + "corpus/real-world/arraypool-span-view-after-return/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-span-view-after-return/before.cs", + "line": 0, + "method": "PoolSpanViewAfterReturn.Scramble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-span-view-after-return/before.cs", + "line": 0, + "method": "PoolSpanViewAfterReturn.Scramble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-use-after-return/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2735, + "digest": "433acedb984502a4033badd58e9a1529113ed16076b8ffc80447d5b8cc9bff88" + }, + "inputs": [ + "corpus/real-world/arraypool-use-after-return/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-use-after-return/after.cs", + "line": 0, + "method": "PoolUseAfterReturn.Divide", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-use-after-return/after.cs", + "line": 0, + "method": "PoolUseAfterReturn.Divide", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-use-after-return/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2830, + "digest": "efb359b2636225b5e7ef5b4b6c006dad863553220f87493078e915d55eec3a6e" + }, + "inputs": [ + "corpus/real-world/arraypool-use-after-return/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-use-after-return/before.cs", + "line": 0, + "method": "PoolUseAfterReturn.Divide", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-use-after-return/before.cs", + "line": 0, + "method": "PoolUseAfterReturn.Divide", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-view-into-field-overread/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 606, + "digest": "cabe61e3c464867e68b999d599c5f83ef0d49724cf3d28f5bfbe0cb508bdaa13" + }, + "inputs": [ + "corpus/real-world/arraypool-view-into-field-overread/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/arraypool-view-into-field-overread/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1510, + "digest": "be50782fc8f098fb9f82bace1fee6a279c0fd2078713db614d98787ea607e6d1" + }, + "inputs": [ + "corpus/real-world/arraypool-view-into-field-overread/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-view-into-field-overread/before.cs", + "line": 0, + "method": "FieldViewFramer.Capture", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/arraypool-view-into-field-overread/before.cs", + "line": 0, + "method": "FieldViewFramer.Capture", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-dispose-via-exchange/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1191, + "digest": "c85bcd1cbd40cbb88b18ac82fc522fd61a495d5404a4cef0c5de8c5627dc4fc1" + }, + "inputs": [ + "corpus/real-world/field-dispose-via-exchange/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-exchange/after.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-exchange/after.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-dispose-via-exchange/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1196, + "digest": "f3dfc0a9cd9f809d4b8386d1c48c3427b3e3bb6935b2ae53934e40012c5c7a81" + }, + "inputs": [ + "corpus/real-world/field-dispose-via-exchange/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-exchange/before.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-exchange/before.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-dispose-via-helper/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1182, + "digest": "85a5318802817003fc55f107194b11398e8b72e854a554f82bd0f760cfdc02ef" + }, + "inputs": [ + "corpus/real-world/field-dispose-via-helper/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-helper/after.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-helper/after.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-dispose-via-helper/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1185, + "digest": "f05208a1844265c23a3eccae5306dc41143a8b6a0982f877ff08b5f2a55a1a66" + }, + "inputs": [ + "corpus/real-world/field-dispose-via-helper/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-helper/before.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/field-dispose-via-helper/before.cs", + "line": 0, + "method": "TimerSink.WaitForDispose", + "params": [ + { + "disposable": true, + "index": 0, + "name": "timer", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-noop-dispose-wrapper/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/field-noop-dispose-wrapper/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/field-noop-dispose-wrapper/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 641, + "digest": "011db74b029e53ec3db9d79684980f3e0e570768ad48b74da1f3d42fa475a10a" + }, + "inputs": [ + "corpus/real-world/field-noop-dispose-wrapper/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/local-dispose-via-using-statement/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1120, + "digest": "6e7ce96fca6b3bfd9baf82f8cc60ebc766900757eea779aa9143371b7a661ae0" + }, + "inputs": [ + "corpus/real-world/local-dispose-via-using-statement/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/local-dispose-via-using-statement/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/local-dispose-via-using-statement/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/local-dispose-via-using-statement/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 690, + "digest": "0bbec5d389f595c5fb610d09ca47b0d4412c9da49562ee22e589973ad5094f7f" + }, + "inputs": [ + "corpus/real-world/local-dispose-via-using-statement/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/local-dispose-via-using-statement/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/local-dispose-via-using-statement/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-double-dispose/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1127, + "digest": "8d1fbc8a549b59016db4416d103572b8940e87ff40bf09b22e7871a757264c18" + }, + "inputs": [ + "corpus/real-world/memorypool-double-dispose/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-double-dispose/after.cs", + "line": 0, + "method": "MemoryPoolDoubleDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-double-dispose/after.cs", + "line": 0, + "method": "MemoryPoolDoubleDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-double-dispose/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1255, + "digest": "7240bfec1a315cd950767e58b7ec1ea745b5f604d7aa15c27a36a73b08237274" + }, + "inputs": [ + "corpus/real-world/memorypool-double-dispose/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-double-dispose/before.cs", + "line": 0, + "method": "MemoryPoolDoubleDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-double-dispose/before.cs", + "line": 0, + "method": "MemoryPoolDoubleDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-owner-escape/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/memorypool-using-owner-escape/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-owner-escape/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1071, + "digest": "605e860e26da849abe7eed1c3b17d96c6bfae4dce89ee224f3de1394306989c8" + }, + "inputs": [ + "corpus/real-world/memorypool-using-owner-escape/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-owner-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingOwnerEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-owner-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingOwnerEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-statement-view-escape/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/memorypool-using-statement-view-escape/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-statement-view-escape/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1088, + "digest": "3615cda941d9ec0041d633a31664e1eddf2e6e48dddf0c7c1da034dc5e1e70f3" + }, + "inputs": [ + "corpus/real-world/memorypool-using-statement-view-escape/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-statement-view-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingStatementViewEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-statement-view-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingStatementViewEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-view-escape/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/memorypool-using-view-escape/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-using-view-escape/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1069, + "digest": "0f25c49e03e043a218263bdd84095249997f18d4af0b4a9ebebc62c58a5dddc3" + }, + "inputs": [ + "corpus/real-world/memorypool-using-view-escape/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-view-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingViewEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-using-view-escape/before.cs", + "line": 0, + "method": "MemoryPoolUsingViewEscape.Borrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-view-after-dispose/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1134, + "digest": "c5b20549d3ddeeab4d0727ef34a142fe84e6f6160055b18fd60d8469cbc0c174" + }, + "inputs": [ + "corpus/real-world/memorypool-view-after-dispose/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-view-after-dispose/after.cs", + "line": 0, + "method": "MemoryPoolViewAfterDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-view-after-dispose/after.cs", + "line": 0, + "method": "MemoryPoolViewAfterDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/memorypool-view-after-dispose/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 823, + "digest": "242d2e078f9e5fc50bab69821882d7ce195af93aa8cee3e735fe51404991b173" + }, + "inputs": [ + "corpus/real-world/memorypool-view-after-dispose/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-view-after-dispose/before.cs", + "line": 0, + "method": "MemoryPoolViewAfterDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/memorypool-view-after-dispose/before.cs", + "line": 0, + "method": "MemoryPoolViewAfterDispose.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2076, + "digest": "45061d72633407fff82f090e76551b391f8029e92badaee7f86047d754c7e74b" + }, + "inputs": [ + "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs", + "line": 0, + "method": "Corpus.PatriciaTree.Get", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs", + "line": 0, + "method": "Corpus.PatriciaTree.Get", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2350, + "digest": "74bcefd1679dfe226597cf7af4d2573301880730619b38c44e2a17fd6673ef88" + }, + "inputs": [ + "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs", + "line": 0, + "method": "Corpus.PatriciaTree.Get", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs", + "line": 0, + "method": "Corpus.PatriciaTree.Get", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-consume/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2911, + "digest": "c5574a2d54a9aeacfa04c4b57788967424ee6b7779ec4812d0fd6aa57c250e56" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-consume/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.Archive", + "params": [ + { + "disposable": true, + "index": 0, + "name": "source", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.RunOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.Archive", + "params": [ + { + "disposable": true, + "index": 0, + "name": "source", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/after.cs", + "line": 0, + "method": "Archiver.RunOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-consume/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3394, + "digest": "c011071c69a1eee0978736e3d25ccfbba9f25e4804ebed0a42ef9259b8780987" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-consume/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Archive", + "params": [ + { + "disposable": true, + "index": 0, + "name": "source", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.RunOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Archive", + "params": [ + { + "disposable": true, + "index": 0, + "name": "source", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Leak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-consume/before.cs", + "line": 0, + "method": "Archiver.RunOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-use-transitive/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 2943, + "digest": "89281cfb4671068cde429e46c1518a25504cf7d592c53a1d54c943a76fd0802a" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-use-transitive/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/after.cs", + "line": 0, + "method": "HandoffUseTransitive.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-use-transitive/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 3033, + "digest": "f7ef00be970baea2af1b59e923f488999db22e4da8845056080905df70c4bbbd" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-use-transitive/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Inner", + "params": [ + { + "disposable": true, + "index": 0, + "name": "s", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use-transitive/before.cs", + "line": 0, + "method": "HandoffUseTransitive.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-use/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1871, + "digest": "95be81b557519762c6d50700120fffd0bc7457dbe7ea986ed06927db0dbc4c08" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-use/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/after.cs", + "line": 0, + "method": "HandoffUse.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/after.cs", + "line": 0, + "method": "HandoffUse.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/after.cs", + "line": 0, + "method": "HandoffUse.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/after.cs", + "line": 0, + "method": "HandoffUse.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/ownership-handoff-use/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1962, + "digest": "1ec8b456a4298eafbf92fdd1ae8e139abb62f35e7f39c19841010166db4d6f02" + }, + "inputs": [ + "corpus/real-world/ownership-handoff-use/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/before.cs", + "line": 0, + "method": "HandoffUse.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/before.cs", + "line": 0, + "method": "HandoffUse.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/before.cs", + "line": 0, + "method": "HandoffUse.Consume", + "params": [ + { + "disposable": true, + "index": 0, + "name": "sink", + "transfer": "must" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/ownership-handoff-use/before.cs", + "line": 0, + "method": "HandoffUse.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/pool-transfer-via-wrapper-local/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 804, + "digest": "366476374d311deced8d8ff927d94183f9306d91c260d808183694f1f86279b7" + }, + "inputs": [ + "corpus/real-world/pool-transfer-via-wrapper-local/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/pool-transfer-via-wrapper-local/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/pool-transfer-via-wrapper-local/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/pool-transfer-via-wrapper-local/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 853, + "digest": "b9ced6d38d48449712d0954701cad88f4a82261bf52913379cec0396b8b63545" + }, + "inputs": [ + "corpus/real-world/pool-transfer-via-wrapper-local/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/pool-transfer-via-wrapper-local/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/pool-transfer-via-wrapper-local/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/screentogif-loaded-subscription/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1457, + "digest": "223cb264993bc6d140144ef46986975be86c395fa1191a663a47fd8119e88752" + }, + "inputs": [ + "corpus/real-world/screentogif-loaded-subscription/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/screentogif-loaded-subscription/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1364, + "digest": "4194acc87fb3095604b89e867e5066cfd006d877b58e530af23df84a000de222" + }, + "inputs": [ + "corpus/real-world/screentogif-loaded-subscription/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/screentogif-systemevents-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 870, + "digest": "d2a81610487f8e298d1d4ba5cb86461aff193e8466ac3295fec9bf7d8f8f5cdf" + }, + "inputs": [ + "corpus/real-world/screentogif-systemevents-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/screentogif-systemevents-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 695, + "digest": "1e9530d2e28322affdc37448e602200562b57148a8e4f1df0f5d36d18e35f167" + }, + "inputs": [ + "corpus/real-world/screentogif-systemevents-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1068, + "digest": "e39c7c0ee7b58eae27a94846ada780cfe5f403d5e2560678225ed5ac38935968" + }, + "inputs": [ + "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs", + "line": 0, + "method": "VaultCrypto.DeriveCryptoData", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs", + "line": 0, + "method": "VaultCrypto.DeriveCryptoData", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 645, + "digest": "0292fbda9a3938d241637ca201c10daed635109fe189a5b517da1f325d60ba31" + }, + "inputs": [ + "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 646, + "digest": "2c97160ac33a0e5ce0f3c14695e65924ceacf6510b1bc8a3555f55e698ca7cc4" + }, + "inputs": [ + "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/socket-accept-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 666, + "digest": "8ee02890727da67fac200ca8776873ffda128d60c2c256897b4536b94e68f1ea" + }, + "inputs": [ + "corpus/real-world/socket-accept-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/socket-accept-leak/after.cs", + "line": 0, + "method": "SocketAcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/socket-accept-leak/after.cs", + "line": 0, + "method": "SocketAcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/socket-accept-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 908, + "digest": "e238f0ee708d2d2498bb29442e03ecce198ab500b66712cb61f553b40c6a5e94" + }, + "inputs": [ + "corpus/real-world/socket-accept-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/socket-accept-leak/before.cs", + "line": 0, + "method": "SocketAcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/socket-accept-leak/before.cs", + "line": 0, + "method": "SocketAcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/subscription-self-owned-property/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/real-world/subscription-self-owned-property/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/subscription-self-owned-property/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 729, + "digest": "882aeb491c18e9d3f68490a742ebec4110ff3d69fbe9659bd8292fb41b1c7ed7" + }, + "inputs": [ + "corpus/real-world/subscription-self-owned-property/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/tcplistener-accept-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 670, + "digest": "0fad59cb39af3f6e7e058edbc9921631ccf13e8612a200f658527b8b573f179f" + }, + "inputs": [ + "corpus/real-world/tcplistener-accept-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-accept-leak/after.cs", + "line": 0, + "method": "AcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-accept-leak/after.cs", + "line": 0, + "method": "AcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/tcplistener-accept-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 916, + "digest": "14225ebe05f207b6381445e11fd0cd51af68bfdcb6776c723e28e415085e5fe7" + }, + "inputs": [ + "corpus/real-world/tcplistener-accept-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-accept-leak/before.cs", + "line": 0, + "method": "AcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-accept-leak/before.cs", + "line": 0, + "method": "AcceptLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/tcplistener-acceptsocket-leak/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 682, + "digest": "6f7beb79279e491530cf512fcc4873fd2693b7c0574ccdcd1c67b8385798a37c" + }, + "inputs": [ + "corpus/real-world/tcplistener-acceptsocket-leak/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-acceptsocket-leak/after.cs", + "line": 0, + "method": "AcceptSocketLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-acceptsocket-leak/after.cs", + "line": 0, + "method": "AcceptSocketLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/tcplistener-acceptsocket-leak/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 924, + "digest": "2655f555efc313ac4f8af306666c8c991524edf108eeac0b12a8041abd2bb4db" + }, + "inputs": [ + "corpus/real-world/tcplistener-acceptsocket-leak/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-acceptsocket-leak/before.cs", + "line": 0, + "method": "AcceptSocketLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/tcplistener-acceptsocket-leak/before.cs", + "line": 0, + "method": "AcceptSocketLeak.Serve", + "params": [ + { + "disposable": true, + "index": 0, + "name": "listener", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/using-statement-throw-releases/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1708, + "digest": "58b6ae72dba9c86bb03316768d677a1cc68e6f5bacada41be68053413c4bfb51" + }, + "inputs": [ + "corpus/real-world/using-statement-throw-releases/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/using-statement-throw-releases/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/using-statement-throw-releases/after.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/real-world/using-statement-throw-releases/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1949, + "digest": "2351bd3969c61c5c4ee9a3eb65865cd248ca61703fb00938b0cff92b202a79d4" + }, + "inputs": [ + "corpus/real-world/using-statement-throw-releases/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/using-statement-throw-releases/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/real-world/using-statement-throw-releases/before.cs", + "line": 0, + "method": "Demo.Run", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/custom-weak-wrapper/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/wpf/custom-weak-wrapper/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/custom-weak-wrapper/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 716, + "digest": "554f01c455b9caee5af33a6d41e4c37812c7e76499b6f18cb0c17a2b1dc9fcc8" + }, + "inputs": [ + "corpus/wpf/custom-weak-wrapper/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/field-use-after-dispose/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 630, + "digest": "5e8403976ee5c58dd9c8ccb8633047948ab25eaf5146f3ce74aec047557c488a" + }, + "inputs": [ + "corpus/wpf/field-use-after-dispose/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/field-use-after-dispose/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1158, + "digest": "baee2ef7b40f1846f826946bf0b15895d9a9a13b2378ffc54021efefc639eb54" + }, + "inputs": [ + "corpus/wpf/field-use-after-dispose/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/field-use-after-dispose/before.cs", + "line": 0, + "method": "ReportViewModel.OnDataChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/field-use-after-dispose/before.cs", + "line": 0, + "method": "ReportViewModel.OnDataChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 644, + "digest": "43ffcf8338181c07bd62ba9ad5374a19cfc6747f516b3b64f8f829fc88b4d45f" + }, + "inputs": [ + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1188, + "digest": "b306fc7240c43ca9f2eaa15878112e3e54a5cec00fd89d895557c780b563c517" + }, + "inputs": [ + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs", + "line": 0, + "method": "SourceView.OnSourceChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs", + "line": 0, + "method": "SourceView.OnSourceChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/handler-use-after-dispose/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 634, + "digest": "326ab79aac370e315311229a45cc2016fbc74c7a1253f1439a32b1734237f9ad" + }, + "inputs": [ + "corpus/wpf/handler-use-after-dispose/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/handler-use-after-dispose/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1170, + "digest": "cc300ea04b282ad37fb475ba1b1800ea5c10237cd8e3a982ca31f6585136b69b" + }, + "inputs": [ + "corpus/wpf/handler-use-after-dispose/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/handler-use-after-dispose/before.cs", + "line": 0, + "method": "CustomerViewModel.OnCustomerChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/handler-use-after-dispose/before.cs", + "line": 0, + "method": "CustomerViewModel.OnCustomerChanged", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/pooled-view-after-dispose/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/wpf/pooled-view-after-dispose/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/pooled-view-after-dispose/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 749, + "digest": "77ef7b8af94100f1680b81c3eec800a060494162d721439df59c92455b92495b" + }, + "inputs": [ + "corpus/wpf/pooled-view-after-dispose/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/pooled-view-after-dispose/before.cs", + "line": 0, + "method": "FrameDecoder.OnFrameReady", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095/corpus/wpf/pooled-view-after-dispose/before.cs", + "line": 0, + "method": "FrameDecoder.OnFrameReady", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 908, + "digest": "a9480b71d0e45fff2d31cc7985e73d176e4591b6b66583893ca00ba062bcc467" + }, + "inputs": [ + "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 910, + "digest": "c49e979336abff7186e0a078a0aee5625a47b55de8262a48739de8c05698bcf2" + }, + "inputs": [ + "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-disposing-else-branch-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 768, + "digest": "79d3ff4102dac8935180d3fb1fa4681bfa0cd391e19da0a4e5ef9929f234d350" + }, + "inputs": [ + "corpus/wpf/subscription-disposing-else-branch-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-disposing-else-branch-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 770, + "digest": "a9eff839199f649ff0deb2490e9de138cbb9ed1e4214104caa9cd3fd1c81e460" + }, + "inputs": [ + "corpus/wpf/subscription-disposing-else-branch-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-explicit-delegate-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 764, + "digest": "8743b538ccdb6f7ad482215c1bfe19196c20f29ac90d7c722f12326c504ac74a" + }, + "inputs": [ + "corpus/wpf/subscription-explicit-delegate-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-explicit-delegate-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 766, + "digest": "ed2c416a93b08944c2dc8f0d0b5191ac66b2f0a73f712fee4ae24238c68c0259" + }, + "inputs": [ + "corpus/wpf/subscription-explicit-delegate-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-finalizer-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 736, + "digest": "9a194ba5bf46daf4862e9ffff22321d05e1cfd69d0e2b4217dfbb390d19b1d10" + }, + "inputs": [ + "corpus/wpf/subscription-finalizer-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-finalizer-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 738, + "digest": "744162c120c4edf7d3b0fcc1f9eee53c1e6a5d012288dabafb97c058facb8737" + }, + "inputs": [ + "corpus/wpf/subscription-finalizer-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-nonteardown-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 720, + "digest": "eb2edf8684887a265864fe321d1f45e6a280ef793bb6420daa3bac8f37008628" + }, + "inputs": [ + "corpus/wpf/subscription-nonteardown-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-nonteardown-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 722, + "digest": "6463c6087d6eba36c160f1804d165ce953e7424c02f8fbed66038f81297c3d18" + }, + "inputs": [ + "corpus/wpf/subscription-nonteardown-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-overload-conflated-cleanup/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 724, + "digest": "2f6fe06a07529bc8448b2bed336f49fd73d0993ce15b7be2e3a34ee436cf5419" + }, + "inputs": [ + "corpus/wpf/subscription-overload-conflated-cleanup/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-overload-conflated-cleanup/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 726, + "digest": "024a7d5e4c233f87269ce022709875b740e01a5f48bb32b0c9d9df47a4138d69" + }, + "inputs": [ + "corpus/wpf/subscription-overload-conflated-cleanup/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-param-guarded-unregister/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 766, + "digest": "8357fdf69d6c99ee66858399221578895e01986724fe944c7389cdc9c5230739" + }, + "inputs": [ + "corpus/wpf/subscription-param-guarded-unregister/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-param-guarded-unregister/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 768, + "digest": "80211f1c6f77601af1ee8ea6c067ccc319f3631b945a4c600c42b28df70a5894" + }, + "inputs": [ + "corpus/wpf/subscription-param-guarded-unregister/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-target-typed-delegate-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 740, + "digest": "6d497efa32b7716e58297c11065c8ed936680f34f89511e3733dfe6a6b231c5d" + }, + "inputs": [ + "corpus/wpf/subscription-target-typed-delegate-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-target-typed-delegate-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 742, + "digest": "66cbf07fe31283239646288663c68b20f7d1053cd023c68570899c65eb1c3c83" + }, + "inputs": [ + "corpus/wpf/subscription-target-typed-delegate-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-teardown-early-return-guard/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 771, + "digest": "4b9807711736129a240364322dfe9b8146209c989296c685186b347c01ba09dd" + }, + "inputs": [ + "corpus/wpf/subscription-teardown-early-return-guard/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-teardown-early-return-guard/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 773, + "digest": "7088a5daffa66b7685d4cfb029240bc95386dc1b839f64daf7da89422ae696fc" + }, + "inputs": [ + "corpus/wpf/subscription-teardown-early-return-guard/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-uncalled-local-function/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 734, + "digest": "ec2ad7cbc261709f93494385d9aa02aba00db24250332e2a992a57ad8641523f" + }, + "inputs": [ + "corpus/wpf/subscription-uncalled-local-function/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-uncalled-local-function/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1242, + "digest": "463319ba792170cc651930d030ffb9b7279220d0ae97eb16342ed57bbd4a419f" + }, + "inputs": [ + "corpus/wpf/subscription-uncalled-local-function/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-xaml-name-only-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 1229, + "digest": "c576b1e0f013b89edaae4443c8bb7ba04faa02c3560bf84c5cda87436c4d9e63" + }, + "inputs": [ + "corpus/wpf/subscription-xaml-name-only-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/subscription-xaml-name-only-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 728, + "digest": "5c2e16858e3a609f462be206fb992ec8846b760701e219dc5b2e10b2529ff06a" + }, + "inputs": [ + "corpus/wpf/subscription-xaml-name-only-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/systemevents-region-escape/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 849, + "digest": "2b95b9ec0b27f704a6fdbf0edb413a6578187a6e16a2ad1f63a2f45862833315" + }, + "inputs": [ + "corpus/wpf/systemevents-region-escape/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/systemevents-region-escape/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 674, + "digest": "84e0ea5e2dca863a37b78485b8d7771ca2c746b4428a9eea0f344274f3013cb3" + }, + "inputs": [ + "corpus/wpf/systemevents-region-escape/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-disposing-else-branch/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 687, + "digest": "a42f6a0c43693a09c7484b570b374a4970b7ce50373948ced410ec7bcfc91928" + }, + "inputs": [ + "corpus/wpf/timer-stop-disposing-else-branch/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-disposing-else-branch/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 689, + "digest": "69066ec33280196711938348368eca9e0a63ab40875490e6eea103e5cd7fe02b" + }, + "inputs": [ + "corpus/wpf/timer-stop-disposing-else-branch/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-early-return-guard/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 684, + "digest": "7eaeac46eceb26d3a7c8035658e33f23b90503fe6467ec10bfdf42590c6f4f1e" + }, + "inputs": [ + "corpus/wpf/timer-stop-early-return-guard/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-early-return-guard/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 686, + "digest": "71ef3b7b65bb5ff1d8ab86eb4b3f3825785538e66c03e8ca75b898659de2d2aa" + }, + "inputs": [ + "corpus/wpf/timer-stop-early-return-guard/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-finalizer-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 689, + "digest": "8d6d55e578516af8d7a1061279896b7c254044203d9fcf3e6d86ddda4ee79798" + }, + "inputs": [ + "corpus/wpf/timer-stop-finalizer-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-finalizer-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 691, + "digest": "bbf1cbda6b5df6d1f745ad7b300d224702d1a57d92f58fc86ba6f7976b7987bb" + }, + "inputs": [ + "corpus/wpf/timer-stop-finalizer-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-nonteardown-release/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 685, + "digest": "da2d8981151e366a383e1539674812dcce74d77d41db2d20fa5fdc8d0afdaca3" + }, + "inputs": [ + "corpus/wpf/timer-stop-nonteardown-release/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-nonteardown-release/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 687, + "digest": "061b4876c9c64bb72a5f1ca9d824ecc81a5a260520e126e0bbc646450c50cafd" + }, + "inputs": [ + "corpus/wpf/timer-stop-nonteardown-release/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-param-guarded/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 679, + "digest": "f1e30766d4c68277af8e96391a07a8bc184ec2339a5fdbbada0140a21ed30e51" + }, + "inputs": [ + "corpus/wpf/timer-stop-param-guarded/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-param-guarded/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 681, + "digest": "4d63866cc5ed269104801797f68a1d3ce2466c00648517e68aa045f7275d95ca" + }, + "inputs": [ + "corpus/wpf/timer-stop-param-guarded/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-uncalled-helper/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 688, + "digest": "4aabf4a2c5c0ac41bdc1c647e688919c352dcb8ce8bfcd4f7b7c1c4b46f139d4" + }, + "inputs": [ + "corpus/wpf/timer-stop-uncalled-helper/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-uncalled-helper/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 690, + "digest": "542694de6eed5843aaa7420cecf4f1a4d943087483b6670829d65668d5fd058f" + }, + "inputs": [ + "corpus/wpf/timer-stop-uncalled-helper/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-uncalled-lambda/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 682, + "digest": "79b3d88249293aa6979793eb765fd28a07e47ecf13e239bcb1e85703f813411b" + }, + "inputs": [ + "corpus/wpf/timer-stop-uncalled-lambda/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-uncalled-lambda/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 684, + "digest": "e0ca56070efb1d5717fd2002cf11d43ebd4c13624ce8b9351dd348d7fff393af" + }, + "inputs": [ + "corpus/wpf/timer-stop-uncalled-lambda/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-unwired-lifecycle/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 685, + "digest": "b990f0b57d53afc6de052c88dce7d5cdd4d3f015e6878ce2ac5ec118880e5b4c" + }, + "inputs": [ + "corpus/wpf/timer-stop-unwired-lifecycle/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-unwired-lifecycle/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 687, + "digest": "780c8d804ca78547a3e5bc29ba3cc8ecb288de9c76ce8a377686715a8f7e5003" + }, + "inputs": [ + "corpus/wpf/timer-stop-unwired-lifecycle/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-wrong-receiver/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 924, + "digest": "24289b5a941ae6e030cfd911731ae910893e0dbce2396e4dc8afd9caa8ddcda0" + }, + "inputs": [ + "corpus/wpf/timer-stop-wrong-receiver/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/timer-stop-wrong-receiver/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 926, + "digest": "23e5e379b9a8748d23e1aa59e693231d2a62f30298338753b3d1bfa02c93a3b3" + }, + "inputs": [ + "corpus/wpf/timer-stop-wrong-receiver/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/viewmodel-escapes-to-app/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/wpf/viewmodel-escapes-to-app/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/viewmodel-escapes-to-app/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 642, + "digest": "cfb0048886cda8835f01302498e450971372807af32c8bd0402c9fed5d3aed4f" + }, + "inputs": [ + "corpus/wpf/viewmodel-escapes-to-app/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/zombie-viewmodel/after.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 221, + "digest": "1495062048b1e5a30dc60b700f08bc8c58a993eb0cf8e226c20d8cbd1943e381" + }, + "inputs": [ + "corpus/wpf/zombie-viewmodel/after.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + }, + "corpus/wpf/zombie-viewmodel/before.cs": { + "facts": { + "algorithm": "sha256", + "bytes": 651, + "digest": "e9ec14e9a944c5bcf6cfdc1101ec2a00635437e63acd3e53cb9344da85730e14" + }, + "inputs": [ + "corpus/wpf/zombie-viewmodel/before.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [], + "unresolved": [] + }, + "status": "produced" + } + } + }, + "execution_profile": { + "dotnet": { + "runtimes": [ + "Microsoft.AspNetCore.App 8.0.31", + "Microsoft.NETCore.App 8.0.31" + ], + "sdk": "8.0.425" + }, + "platform": { + "machine": "x86_64", + "system": "Linux" + }, + "python": { + "implementation": "CPython", + "version": "3.11.15 (main, Sep 19 2026, 00:18:08) [GCC 16.1.1 20260625]" + }, + "rust": { + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "host": "x86_64-unknown-linux-gnu", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8" + } + }, + "input_roots": [ + "corpus/real-world", + "corpus/wpf", + "corpus/di", + "corpus/fixtures", + "corpus/p036-bakeoff" + ], + "instrument_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py" + ], + "is_evidence": true, + "materialization_root": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095", + "population_commit": "4a8e6582e10222403cd40adc9e95db7e0228a1c2", + "post_run_population_intact": true, + "reference_profile": { + "OWN_EXTRA_REF_DIRS": "removed-from-child-environment", + "observed_extra_reference_lines": 0 + }, + "schema": "p037-mos-snapshot/2", + "source": "corpus", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2", + "subject_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py", + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ], + "support_manifest": [], + "support_manifest_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "treatment_paths": [ + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ] +} diff --git a/docs/evidence/p037-a2.1-after-mos-repo.json b/docs/evidence/p037-a2.1-after-mos-repo.json new file mode 100644 index 00000000..1fca78a7 --- /dev/null +++ b/docs/evidence/p037-a2.1-after-mos-repo.json @@ -0,0 +1,2672 @@ +{ + "analysis_manifest": [ + { + "blob": "db9868f0e8b9fcbe286f8f810ccc988416f10b1e", + "path": "audit/runtime/DuplicateDetector/Program.cs" + }, + { + "blob": "61d10bce7d57789882a0b9c1e3269bede7ee5271", + "path": "audit/runtime/LeakHarness/HeapCounter.cs" + }, + { + "blob": "0e6a1d74575c72c621b6aa5afe9f3e3bc2594e19", + "path": "audit/runtime/LeakHarness/Program.cs" + }, + { + "blob": "76f0aa4c197925c0cbbe5094986c25ef8c5f57fc", + "path": "audit/runtime/LeakHarness/Scenario.cs" + }, + { + "blob": "0de2cf83746dcb98f28bd774eeeb0b4cc6915b0f", + "path": "audit/runtime/PropertyChangedStorm/Program.cs" + }, + { + "blob": "14234cabf0d3f931dda84c0f921980e4f9bbd612", + "path": "audit/runtime/RetentionPath/Heap.cs" + }, + { + "blob": "72f149c65a97590f677bc76afcff933107afac20", + "path": "audit/runtime/RetentionPath/Program.cs" + }, + { + "blob": "f803433a54e23a6845792fd2050969d3f4da5a85", + "path": "frontend/roslyn/Owen.CSharp.Rewriter/Program.cs" + }, + { + "blob": "e2a7caf1437892347df186a7a5636c032651d320", + "path": "frontend/roslyn/OwnSharp.Cli/CheckCommand.cs" + }, + { + "blob": "14d9afdfcae183bcc1a36cb66713e5cac1ee2779", + "path": "frontend/roslyn/OwnSharp.Cli/CompareMode.cs" + }, + { + "blob": "29b16c9d30bd974e04125a32bec345ca5596334a", + "path": "frontend/roslyn/OwnSharp.Cli/CoreVendor.cs" + }, + { + "blob": "a51855e9f0a5f7ad5dd942dca5c4313fd99b032e", + "path": "frontend/roslyn/OwnSharp.Cli/CrashReport.cs" + }, + { + "blob": "58453947817b0e874d5ad6e17e1e4a49b7c125b5", + "path": "frontend/roslyn/OwnSharp.Cli/EngineRunner.cs" + }, + { + "blob": "ad30d037b862776072d3474d367f9f1628cb139a", + "path": "frontend/roslyn/OwnSharp.Cli/EngineSelection.cs" + }, + { + "blob": "6674fe0270f82f12e4472078d8e2b4a2a57cf5bd", + "path": "frontend/roslyn/OwnSharp.Cli/Program.cs" + }, + { + "blob": "d78c5d2a072fe22a6cdc39c416506df77e51bdf5", + "path": "frontend/roslyn/OwnSharp.Cli/PythonResolver.cs" + }, + { + "blob": "c83babf3a205f81e86581c418dcb97bbe3226fd5", + "path": "frontend/roslyn/OwnSharp.Cli/RustCoreLocator.cs" + }, + { + "blob": "07cb275070130437ec22207978e3b9fd9718c13f", + "path": "frontend/roslyn/OwnSharp.Cli/ToolVersion.cs" + }, + { + "blob": "33bd542eed196609315330b524086c6e6d5d117f", + "path": "frontend/roslyn/OwnSharp.Extractor/Program.cs" + }, + { + "blob": "b90d2916e1d6725d20c7a97af1647f73215413eb", + "path": "frontend/roslyn/OwnSharp.WeakTargetProbe/Program.cs" + }, + { + "blob": "faf652745bc629ad77f51f8aaeeb220fbf810463", + "path": "frontend/roslyn/project-input-sample/CustomerSubscription.cs" + }, + { + "blob": "8ea4797f7c567316194b4a452bbf6e0d8ee10a9d", + "path": "frontend/roslyn/samples/AliasDisposeSample.cs" + }, + { + "blob": "6031f887cfb754c9de522b843d8d8a547eab32e6", + "path": "frontend/roslyn/samples/AliasedSourceViewModel.cs" + }, + { + "blob": "55ff2b817a92c0da3d2081ca91d6d29671de54d9", + "path": "frontend/roslyn/samples/AppDomainShutdownSample.cs" + }, + { + "blob": "a7dbe6708effae84dfcf9f8057bb756de6e980f2", + "path": "frontend/roslyn/samples/AppLifetimeSample.cs" + }, + { + "blob": "37f8adf21b1e9b2d27e6baf91e84b83de163cb8b", + "path": "frontend/roslyn/samples/AppScopedSourceSample.cs" + }, + { + "blob": "08096e0cc1b6aafc79eed60e5c6ef547e4056e4f", + "path": "frontend/roslyn/samples/AssociatedObjectSourceSample.cs" + }, + { + "blob": "9e6a77034b2e031631fb76745ef55a00d82bc3c8", + "path": "frontend/roslyn/samples/BodyThrowEdgesSample.cs" + }, + { + "blob": "c5ac84d050c01ed6139a2f691b71dce1b014b41b", + "path": "frontend/roslyn/samples/CloseReleaseSample.cs" + }, + { + "blob": "02fb37ca09d02cea02e2a47ed117a0152ad573a9", + "path": "frontend/roslyn/samples/ColumnAnchorsSample.cs" + }, + { + "blob": "21aa5461b2218dd5ca3f5e7af4180ac439ed9e46", + "path": "frontend/roslyn/samples/CustomerViewModel.cs" + }, + { + "blob": "c10f0f0ec7276d6662a2b373a37b90190d2515eb", + "path": "frontend/roslyn/samples/DiCaptiveSample.cs" + }, + { + "blob": "101d4360a6975cd22ff53878c1d8fe1285dd3625", + "path": "frontend/roslyn/samples/DisposableFieldViewModel.cs" + }, + { + "blob": "a51987e54a530a7599e0b380b14f997156567547", + "path": "frontend/roslyn/samples/DpRotationSample.cs" + }, + { + "blob": "cd7d85bb4c42d6fa4765440ba02573a8d904e4ce", + "path": "frontend/roslyn/samples/EmptyDisposeSample.cs" + }, + { + "blob": "b2ac5868a5b4a14f1c9581ccc08e36bea2a96c1d", + "path": "frontend/roslyn/samples/EventSourceCountersSample.cs" + }, + { + "blob": "91e723c120a686971ca2b7efaabfa306b9d831b2", + "path": "frontend/roslyn/samples/ExternalRefSubscription.cs" + }, + { + "blob": "60233494795aa9b81fd7fabe227343305acb3548", + "path": "frontend/roslyn/samples/FactoryAdoptSample.cs" + }, + { + "blob": "9fb14588b0d77049f20cc9cfd94b1c8bc01bcf8f", + "path": "frontend/roslyn/samples/FactoryLeakSample.cs" + }, + { + "blob": "b85092085ad8b6cd5b5b199cc26c8921c41dd605", + "path": "frontend/roslyn/samples/FieldReleaseSample.cs" + }, + { + "blob": "4c8a6927f8ed6437ca50e4dba61093e79b907e61", + "path": "frontend/roslyn/samples/FixCandidatesSample.cs" + }, + { + "blob": "5d63dcb6470a2c50a8f4cbe0fe2d19cf7fd3a465", + "path": "frontend/roslyn/samples/FixRewriteSample.cs" + }, + { + "blob": "8139f06f89bda2826ac092cf9895bb1d52c2e930", + "path": "frontend/roslyn/samples/FlowLocalsSample.cs" + }, + { + "blob": "b9ba1bd05f7c3a4ba3447905cf1f8cd8e0efc561", + "path": "frontend/roslyn/samples/InjectedDcViewSample.xaml.cs" + }, + { + "blob": "b1526d6820914accc93cf517094dcd9e6362b57b", + "path": "frontend/roslyn/samples/LambdaHandlerViewModel.cs" + }, + { + "blob": "d9e97be3849357732f4cddd71692866d54b08909", + "path": "frontend/roslyn/samples/LambdaTiersSample.cs" + }, + { + "blob": "a1c7d3cdd2f59a9e9f295456c7900b65c86c5fcb", + "path": "frontend/roslyn/samples/LocalDisposableSample.cs" + }, + { + "blob": "20f7002ac617caae05053efad11b1c6626830493", + "path": "frontend/roslyn/samples/MemoryOwnerEscapeSample.cs" + }, + { + "blob": "d7d17688ee408e9f400840f42cd649edd67098a3", + "path": "frontend/roslyn/samples/MessengerViewModel.cs" + }, + { + "blob": "8c78b8537be0bd6dd22a9d331bbbc3649030e07a", + "path": "frontend/roslyn/samples/OrdersViewModel.cs" + }, + { + "blob": "b27be0a78d81e6d40117f627c01c70686dbb9309", + "path": "frontend/roslyn/samples/OverloadSigSample.cs" + }, + { + "blob": "2a151381d555094a533c99ad6de777562c5e29e3", + "path": "frontend/roslyn/samples/OwnIgnoreSample.cs" + }, + { + "blob": "ed6813a5ab0a7c0c4b83099851665d7981e66e12", + "path": "frontend/roslyn/samples/OwnedCollectionElementSample.cs" + }, + { + "blob": "0337264bc3de8a385aa34868a25e106b21a5c0ef", + "path": "frontend/roslyn/samples/PipeFieldsSample.cs" + }, + { + "blob": "76592f6a3b5a4ff9267281cec30f85a6ea73c9e3", + "path": "frontend/roslyn/samples/PooledBufferSample.cs" + }, + { + "blob": "51825daad0d71588bc131cea2f8a141df116fc40", + "path": "frontend/roslyn/samples/RequerySuggestedAllowlistSample.cs" + }, + { + "blob": "2d9c2b2f1e9968d779ee1c143ebf9700a06e04eb", + "path": "frontend/roslyn/samples/ResolvedDisposableSample.cs" + }, + { + "blob": "af288a010502b698abe3f3c89c8b926d02602ed5", + "path": "frontend/roslyn/samples/ReturnedPublisherSample.cs" + }, + { + "blob": "b333b55e02c363f7fdf1a3b4dd6614c30ee809de", + "path": "frontend/roslyn/samples/SampleTypes.cs" + }, + { + "blob": "43775ca64f0fa022bad0a0e5fd4ab81a0388a63a", + "path": "frontend/roslyn/samples/SelfDetachingHandlerSample.cs" + }, + { + "blob": "2dc120c7cc0da9897b2dedbc4cf08a18f41e09bb", + "path": "frontend/roslyn/samples/SelfOwnedControlParts.cs" + }, + { + "blob": "c5d9e33e7aab3b008fdd49b6ea678340ab5805df", + "path": "frontend/roslyn/samples/SelfOwnedViewModel.cs" + }, + { + "blob": "76b04623e0e45ef8710cca1ad27733f67b62dafa", + "path": "frontend/roslyn/samples/SemaphoreFieldSample.cs" + }, + { + "blob": "e31cab4f6892f48041a3e881c980a8bbdd4773ea", + "path": "frontend/roslyn/samples/StaticClassEscapeSample.cs" + }, + { + "blob": "c3f958ded180e900a396f73bed3173fefcd44a6a", + "path": "frontend/roslyn/samples/StaticEventEscapeViewModel.cs" + }, + { + "blob": "921a969a9e683e1168d5fa4df1be86d216c1b272", + "path": "frontend/roslyn/samples/StaticHandlerViewModel.cs" + }, + { + "blob": "8d7ffe27b6b75c063b8f2d87bdefa12993737035", + "path": "frontend/roslyn/samples/TemplatePartLocalCaptureSample.cs" + }, + { + "blob": "31961de2bbd09e3cf564ae1b32d1d5ec31312ca8", + "path": "frontend/roslyn/samples/TierBSample.cs" + }, + { + "blob": "0b7d93c5d460dac3d2b08c209a3fb6de20c6eeb2", + "path": "frontend/roslyn/samples/TimerViewModel.cs" + }, + { + "blob": "369eeb6b860eb57766bf925ca432e73e8a4e2d55", + "path": "frontend/roslyn/samples/UnitOfWorkFlowSample.cs" + }, + { + "blob": "56c7601cf82f008e0c1c3bc7fcd19203b076fcb3", + "path": "frontend/roslyn/samples/UsingFieldAcquisitionSample.cs" + }, + { + "blob": "c704b62363503bdf08ff441d1e0ddbe2646af939", + "path": "frontend/roslyn/samples/ViewOwnsVmSample.xaml.cs" + }, + { + "blob": "fa1e6e2ba28c9c61679a373afd42cedf0fc6f6df", + "path": "frontend/roslyn/samples/VoidSubscribeSample.cs" + }, + { + "blob": "f067d4bbaba417247264b614a5b64e24283a3e47", + "path": "frontend/roslyn/samples/WeakSubscribeAllowlistSample.cs" + }, + { + "blob": "49d4b1aa29d6fffb4a66bef39698c14e4e3e1d03", + "path": "frontend/roslyn/samples/WeakSubscribeRxNoEventsSample.cs" + }, + { + "blob": "e4a3925648e8f40e4659b3ee87ed6da7b8160d98", + "path": "frontend/roslyn/samples/WeakSubscribeUnresolvedSample.cs" + }, + { + "blob": "24a344692519d34e6b3eea683e854c7d2973abab", + "path": "frontend/roslyn/samples/WhenAnyValueViewModel.cs" + }, + { + "blob": "47242c681bca9f6e98cf06e0cfddd46764205140", + "path": "frontend/roslyn/samples/WinFormsDisposalSample.cs" + }, + { + "blob": "dcc97874007b671df84d40bf24c48a76ebd40fe2", + "path": "frontend/roslyn/samples/WinFormsModelessSample.cs" + }, + { + "blob": "0487e4847c221f7256c2598a523a0a4037ed0906", + "path": "frontend/roslyn/samples/weaved-linked/Shared/SharedEnumerator.cs" + }, + { + "blob": "ce79c24883be50189a02547d148aca4bff80b770", + "path": "frontend/roslyn/samples/weaved/WeavedEmptyDispose.cs" + } + ], + "analysis_manifest_sha256": "325a580da5dc78493744e080fb497a4bba5fc6b21c8a01058793b99686cb894a", + "artifacts": { + "own-shadow-engine": { + "binary": "own-shadow-engine", + "bytes": 1819088, + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "cargo_argv": [ + "cargo", + "build", + "--locked", + "--release", + "--message-format=json", + "-p", + "own-shadow", + "--bin", + "own-shadow-engine" + ], + "cargo_clean_argv": [ + "cargo", + "clean", + "--release", + "-p", + "own-shadow" + ], + "cargo_lock_blob": "d8adbb1dc4d90da0c80aa1a2d8ba85bef805620f", + "cargo_lock_sha256": "17553420691d96febcfac54bd8f530b4f9e2a1ad7c79e6aaa022510e56692f45", + "dirty": false, + "executable": "/home/tandem/cargo-target/release/own-shadow-engine", + "executed": { + "bytes": 1819088, + "post_run_intact": true, + "sealed_path": "/home/tandem/owen-p037-a2/tmp/p037-take-yky8i08r/own-shadow-engine", + "sha256": "21a311088337be0875d8803a51ce1be726bba5a5efe672359ed9dfdb8511e210" + }, + "host": "x86_64-unknown-linux-gnu", + "package": "own-shadow", + "profile": "release", + "rebuilt_by_this_call": true, + "repo_path": null, + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8", + "sha256": "21a311088337be0875d8803a51ce1be726bba5a5efe672359ed9dfdb8511e210", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2" + } + }, + "dirty": false, + "documents": { + "repo-tree": { + "facts": { + "algorithm": "sha256", + "bytes": 159726, + "digest": "e963718057f4a29115513fad4dbb621d9e79d50460d139e8bfb6c1294956942b" + }, + "inputs": [ + "audit/runtime/DuplicateDetector/Program.cs", + "audit/runtime/LeakHarness/HeapCounter.cs", + "audit/runtime/LeakHarness/Program.cs", + "audit/runtime/LeakHarness/Scenario.cs", + "audit/runtime/PropertyChangedStorm/Program.cs", + "audit/runtime/RetentionPath/Heap.cs", + "audit/runtime/RetentionPath/Program.cs", + "frontend/roslyn/Owen.CSharp.Rewriter/Program.cs", + "frontend/roslyn/OwnSharp.Cli/CheckCommand.cs", + "frontend/roslyn/OwnSharp.Cli/CompareMode.cs", + "frontend/roslyn/OwnSharp.Cli/CoreVendor.cs", + "frontend/roslyn/OwnSharp.Cli/CrashReport.cs", + "frontend/roslyn/OwnSharp.Cli/EngineRunner.cs", + "frontend/roslyn/OwnSharp.Cli/EngineSelection.cs", + "frontend/roslyn/OwnSharp.Cli/Program.cs", + "frontend/roslyn/OwnSharp.Cli/PythonResolver.cs", + "frontend/roslyn/OwnSharp.Cli/RustCoreLocator.cs", + "frontend/roslyn/OwnSharp.Cli/ToolVersion.cs", + "frontend/roslyn/OwnSharp.Extractor/Program.cs", + "frontend/roslyn/OwnSharp.WeakTargetProbe/Program.cs", + "frontend/roslyn/project-input-sample/CustomerSubscription.cs", + "frontend/roslyn/samples/AliasDisposeSample.cs", + "frontend/roslyn/samples/AliasedSourceViewModel.cs", + "frontend/roslyn/samples/AppDomainShutdownSample.cs", + "frontend/roslyn/samples/AppLifetimeSample.cs", + "frontend/roslyn/samples/AppScopedSourceSample.cs", + "frontend/roslyn/samples/AssociatedObjectSourceSample.cs", + "frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "frontend/roslyn/samples/CloseReleaseSample.cs", + "frontend/roslyn/samples/ColumnAnchorsSample.cs", + "frontend/roslyn/samples/CustomerViewModel.cs", + "frontend/roslyn/samples/DiCaptiveSample.cs", + "frontend/roslyn/samples/DisposableFieldViewModel.cs", + "frontend/roslyn/samples/DpRotationSample.cs", + "frontend/roslyn/samples/EmptyDisposeSample.cs", + "frontend/roslyn/samples/EventSourceCountersSample.cs", + "frontend/roslyn/samples/ExternalRefSubscription.cs", + "frontend/roslyn/samples/FactoryAdoptSample.cs", + "frontend/roslyn/samples/FactoryLeakSample.cs", + "frontend/roslyn/samples/FieldReleaseSample.cs", + "frontend/roslyn/samples/FixCandidatesSample.cs", + "frontend/roslyn/samples/FixRewriteSample.cs", + "frontend/roslyn/samples/FlowLocalsSample.cs", + "frontend/roslyn/samples/InjectedDcViewSample.xaml.cs", + "frontend/roslyn/samples/LambdaHandlerViewModel.cs", + "frontend/roslyn/samples/LambdaTiersSample.cs", + "frontend/roslyn/samples/LocalDisposableSample.cs", + "frontend/roslyn/samples/MemoryOwnerEscapeSample.cs", + "frontend/roslyn/samples/MessengerViewModel.cs", + "frontend/roslyn/samples/OrdersViewModel.cs", + "frontend/roslyn/samples/OverloadSigSample.cs", + "frontend/roslyn/samples/OwnIgnoreSample.cs", + "frontend/roslyn/samples/OwnedCollectionElementSample.cs", + "frontend/roslyn/samples/PipeFieldsSample.cs", + "frontend/roslyn/samples/PooledBufferSample.cs", + "frontend/roslyn/samples/RequerySuggestedAllowlistSample.cs", + "frontend/roslyn/samples/ResolvedDisposableSample.cs", + "frontend/roslyn/samples/ReturnedPublisherSample.cs", + "frontend/roslyn/samples/SampleTypes.cs", + "frontend/roslyn/samples/SelfDetachingHandlerSample.cs", + "frontend/roslyn/samples/SelfOwnedControlParts.cs", + "frontend/roslyn/samples/SelfOwnedViewModel.cs", + "frontend/roslyn/samples/SemaphoreFieldSample.cs", + "frontend/roslyn/samples/StaticClassEscapeSample.cs", + "frontend/roslyn/samples/StaticEventEscapeViewModel.cs", + "frontend/roslyn/samples/StaticHandlerViewModel.cs", + "frontend/roslyn/samples/TemplatePartLocalCaptureSample.cs", + "frontend/roslyn/samples/TierBSample.cs", + "frontend/roslyn/samples/TimerViewModel.cs", + "frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "frontend/roslyn/samples/UsingFieldAcquisitionSample.cs", + "frontend/roslyn/samples/ViewOwnsVmSample.xaml.cs", + "frontend/roslyn/samples/VoidSubscribeSample.cs", + "frontend/roslyn/samples/WeakSubscribeAllowlistSample.cs", + "frontend/roslyn/samples/WeakSubscribeRxNoEventsSample.cs", + "frontend/roslyn/samples/WeakSubscribeUnresolvedSample.cs", + "frontend/roslyn/samples/WhenAnyValueViewModel.cs", + "frontend/roslyn/samples/WinFormsDisposalSample.cs", + "frontend/roslyn/samples/WinFormsModelessSample.cs", + "frontend/roslyn/samples/weaved-linked/Shared/SharedEnumerator.cs", + "frontend/roslyn/samples/weaved/WeavedEmptyDispose.cs" + ], + "python-ownlang": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.CreateUnitOfWork", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.GetProductsFromCatalogWODocuments", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.ImportProducts", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/ColumnAnchorsSample.cs", + "line": 0, + "method": "ColumnAnchorsSample.TwoLeaksOneLine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.FactoryConsumers.Clean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.FactoryConsumers.Leaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.StreamFactory.Make", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CatchThenDisposeAfter", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.Clean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CryptoFactoryDisposed", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CryptoFactoryLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CtorInLambdaNotThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CtorThrowLeaksPrior", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeAsyncConfiguredInTry", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeInsideIfWithThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeOnThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposedAsyncConfigured", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoubleDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.EarlyReturnLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.Escapes", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForIncrementorBodyUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForeachLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.HasLoop", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.LeakOnElse", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NameofInLambda", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NestedThrowLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NullCondFinallyDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.OutArgRebindSuppressesLaterUse", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.OutArgSiblingUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.PoolReturnedOnOnePath", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.QualifiedTypedCatchLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ReassignedView", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.RefArgUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SemaphoreLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SliceReassignAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SwitchAllDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SwitchOneLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TcpListenerNeverStopped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TcpListenerStopped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ThrowAfterAcquireLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ThrowAfterDisposeClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TimerLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryFinallyClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryFinallyReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryNeverDisposed", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TypedCatchLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.UseAfterDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ValidatedThenClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ValidatedThenLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.WhileClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.WhileLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.AdjacentDisposeClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.MayThrowInFinallyClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.MayThrowLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/CloseReleaseSample.cs", + "line": 0, + "method": "Own.Samples.ClosesOtherInstanceField.CloseOther", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakBareInheritedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakDerived", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakInheritedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakLegacy", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakReader", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakReal", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.UseScratch", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsDisposalSample.cs", + "line": 0, + "method": "Own.Samples.ForeignContainerAdder.AttachTo", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/MemoryOwnerEscapeSample.cs", + "line": 0, + "method": "Own.Samples.MemoryOwnerEscape.PoolOwnerNotEscaped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/MemoryOwnerEscapeSample.cs", + "line": 0, + "method": "Own.Samples.MemoryOwnerEscape.ReadOnlyLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/AppDomainShutdownSample.cs", + "line": 0, + "method": "Own.Samples.NonAppDomainSubscriber..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cts", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/AliasDisposeSample.cs", + "line": 0, + "method": "Own.Samples.ScopedAliasNameLeak.Other", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/weaved/WeavedEmptyDispose.cs", + "line": 0, + "method": "Own.Samples.Weaved.WeavedConsumer.Count", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/audit/runtime/RetentionPath/Program.cs", + "line": 0, + "method": "OwnNet.Audit.Runtime.Program.Census", + "params": [ + { + "disposable": true, + "index": 0, + "name": "walker", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/OwnSharp.Cli/EngineRunner.cs", + "line": 0, + "method": "OwnSharp.Cli.EngineRunner.DrainAsync", + "params": [ + { + "disposable": true, + "index": 0, + "name": "stream", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptDouble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptInnerOnly", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptTargetTyped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.NonAdoptDoubleOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.StreamAdopter..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "inner", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.StreamHolder..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "held", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/PooledBufferSample.cs", + "line": 0, + "method": "PoolApp.Hasher.CleanHash", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/PooledBufferSample.cs", + "line": 0, + "method": "PoolApp.Hasher.LeakyHash", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ConnectionResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ExprBodiedResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.RequestResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ScopedResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Drop", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open", + "params": [ + { + "disposable": true, + "index": 0, + "name": "existing", + "transfer": "no" + } + ], + "returns": { + "owned": "unknown" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open(System.IO.FileStream,System.Boolean)", + "params": [ + { + "disposable": true, + "index": 0, + "name": "existing", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open(System.String)", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/LocalDisposableSample.cs", + "line": 0, + "method": "Streams.Loader.Leaky", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/LocalDisposableSample.cs", + "line": 0, + "method": "Streams.Loader.Transfer", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModalLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModalOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModeless", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModelessConditional", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + }, + "rust-own-bridge": { + "document": { + "degraded": null, + "module": "Extracted", + "ownir_version": 0, + "summaries": [ + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.CreateUnitOfWork", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.GetProductsFromCatalogWODocuments", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/UnitOfWorkFlowSample.cs", + "line": 0, + "method": "Catalog.CatalogService.ImportProducts", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/ColumnAnchorsSample.cs", + "line": 0, + "method": "ColumnAnchorsSample.TwoLeaksOneLine", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.FactoryConsumers.Clean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.FactoryConsumers.Leaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryLeakSample.cs", + "line": 0, + "method": "Factories.StreamFactory.Make", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CatchThenDisposeAfter", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.Clean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CryptoFactoryDisposed", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CryptoFactoryLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CtorInLambdaNotThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.CtorThrowLeaksPrior", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeAsyncConfiguredInTry", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeInsideIfWithThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposeOnThrow", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DisposedAsyncConfigured", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.DoubleDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.EarlyReturnLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.Escapes", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForIncrementorBodyUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ForeachLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.HasLoop", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.LeakOnElse", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NameofInLambda", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NestedThrowLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.NullCondFinallyDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.OutArgRebindSuppressesLaterUse", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.OutArgSiblingUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.PoolReturnedOnOnePath", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.QualifiedTypedCatchLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ReassignedView", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.RefArgUseAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SemaphoreLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SliceReassignAfterReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SwitchAllDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.SwitchOneLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TcpListenerNeverStopped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TcpListenerStopped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ThrowAfterAcquireLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ThrowAfterDisposeClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TimerLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryFinallyClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryFinallyReturn", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TryNeverDisposed", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.TypedCatchLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.UseAfterDispose", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ValidatedThenClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.ValidatedThenLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.WhileClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FlowLocalsSample.cs", + "line": 0, + "method": "FlowLocalsSample.WhileLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.AdjacentDisposeClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.MayThrowInFinallyClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/BodyThrowEdgesSample.cs", + "line": 0, + "method": "Own.Samples.BodyThrowEdgesSample.MayThrowLeaks", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/CloseReleaseSample.cs", + "line": 0, + "method": "Own.Samples.ClosesOtherInstanceField.CloseOther", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakBareInheritedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakDerived", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakInheritedAsync", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakLegacy", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakReader", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.LeakReal", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/EmptyDisposeSample.cs", + "line": 0, + "method": "Own.Samples.EmptyDisposeConsumers.UseScratch", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsDisposalSample.cs", + "line": 0, + "method": "Own.Samples.ForeignContainerAdder.AttachTo", + "params": [ + { + "disposable": true, + "index": 0, + "name": "other", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/MemoryOwnerEscapeSample.cs", + "line": 0, + "method": "Own.Samples.MemoryOwnerEscape.PoolOwnerNotEscaped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/MemoryOwnerEscapeSample.cs", + "line": 0, + "method": "Own.Samples.MemoryOwnerEscape.ReadOnlyLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/AppDomainShutdownSample.cs", + "line": 0, + "method": "Own.Samples.NonAppDomainSubscriber..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "cts", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/AliasDisposeSample.cs", + "line": 0, + "method": "Own.Samples.ScopedAliasNameLeak.Other", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/weaved/WeavedEmptyDispose.cs", + "line": 0, + "method": "Own.Samples.Weaved.WeavedConsumer.Count", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/audit/runtime/RetentionPath/Program.cs", + "line": 0, + "method": "OwnNet.Audit.Runtime.Program.Census", + "params": [ + { + "disposable": true, + "index": 0, + "name": "walker", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/OwnSharp.Cli/EngineRunner.cs", + "line": 0, + "method": "OwnSharp.Cli.EngineRunner.DrainAsync", + "params": [ + { + "disposable": true, + "index": 0, + "name": "stream", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptClean", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptDouble", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptInnerOnly", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.AdoptTargetTyped", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.AdoptConsumers.NonAdoptDoubleOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.StreamAdopter..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "inner", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/FactoryAdoptSample.cs", + "line": 0, + "method": "OwnSharp.Samples.StreamHolder..ctor", + "params": [ + { + "disposable": true, + "index": 0, + "name": "held", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/PooledBufferSample.cs", + "line": 0, + "method": "PoolApp.Hasher.CleanHash", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/PooledBufferSample.cs", + "line": 0, + "method": "PoolApp.Hasher.LeakyHash", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ConnectionResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ExprBodiedResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.RequestResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/DiCaptiveSample.cs", + "line": 0, + "method": "Sample.ScopedResolver.Warm", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Drop", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open", + "params": [ + { + "disposable": true, + "index": 0, + "name": "existing", + "transfer": "no" + } + ], + "returns": { + "owned": "unknown" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open(System.IO.FileStream,System.Boolean)", + "params": [ + { + "disposable": true, + "index": 0, + "name": "existing", + "transfer": "no" + } + ], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/OverloadSigSample.cs", + "line": 0, + "method": "SigOverloads.Open(System.String)", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/LocalDisposableSample.cs", + "line": 0, + "method": "Streams.Loader.Leaky", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/LocalDisposableSample.cs", + "line": 0, + "method": "Streams.Loader.Transfer", + "params": [], + "returns": { + "owned": "fresh" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModalLeak", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModalOk", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModeless", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + }, + { + "file": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849/frontend/roslyn/samples/WinFormsModelessSample.cs", + "line": 0, + "method": "WinFormsModelessSample.OpenModelessConditional", + "params": [], + "returns": { + "owned": "none" + }, + "source": "inferred" + } + ], + "unresolved": [] + }, + "status": "produced" + } + } + }, + "execution_profile": { + "dotnet": { + "runtimes": [ + "Microsoft.AspNetCore.App 8.0.31", + "Microsoft.NETCore.App 8.0.31" + ], + "sdk": "8.0.425" + }, + "platform": { + "machine": "x86_64", + "system": "Linux" + }, + "python": { + "implementation": "CPython", + "version": "3.11.15 (main, Sep 19 2026, 00:18:08) [GCC 16.1.1 20260625]" + }, + "rust": { + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "host": "x86_64-unknown-linux-gnu", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8" + } + }, + "input_roots": [ + "frontend", + "audit" + ], + "instrument_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py" + ], + "is_evidence": true, + "materialization_root": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/325a580da5dc7849", + "population_commit": "4a8e6582e10222403cd40adc9e95db7e0228a1c2", + "post_run_population_intact": true, + "reference_profile": { + "OWN_EXTRA_REF_DIRS": "removed-from-child-environment", + "observed_extra_reference_lines": 0 + }, + "schema": "p037-mos-snapshot/2", + "source": "repo", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2", + "subject_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py", + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ], + "support_manifest": [ + { + "blob": "a070b9f433e0c5fe22afc9f7b33a7efd41026d70", + "mechanism": "sibling-xaml", + "path": "frontend/roslyn/samples/InjectedDcViewSample.xaml" + }, + { + "blob": "344654a106208d92789ff63672693ef823333743", + "mechanism": "sibling-xaml", + "path": "frontend/roslyn/samples/ViewOwnsVmSample.xaml" + }, + { + "blob": "b41ca452d4adffe860129074c164062685b1e37d", + "mechanism": "ancestor-fody", + "path": "frontend/roslyn/samples/weaved/FodyWeavers.xml" + } + ], + "support_manifest_sha256": "9002111b5cdcce3f8d09beb75060b131678f315f6aca708713b884ebf2b553fa", + "treatment_paths": [ + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ] +} diff --git a/docs/evidence/p037-a2.1-after-verdict-python.json b/docs/evidence/p037-a2.1-after-verdict-python.json new file mode 100644 index 00000000..93cf9e1d --- /dev/null +++ b/docs/evidence/p037-a2.1-after-verdict-python.json @@ -0,0 +1,1662 @@ +{ + "analysis_manifest": [ + { + "blob": "38d180096c63c7d01d7bb39601c1f88e3a53f67e", + "path": "corpus/di/singleton-captures-scoped-dbcontext/after.cs" + }, + { + "blob": "4d6f60e065d7e2572bc457e3df6a593b6a4699c4", + "path": "corpus/di/singleton-captures-scoped-dbcontext/before.cs" + }, + { + "blob": "67c4aa0b15fa0782d865cbd1c5ef355fbc926f8f", + "path": "corpus/fixtures/systemevents-console/Program.cs" + }, + { + "blob": "c9d140949acfe06bd187404508a46b6b61a7c89e", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/after.cs" + }, + { + "blob": "c80dee0bc66037c3c4ae7ff8ce8125ba145f8156", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/before.cs" + }, + { + "blob": "b13ab3891e11f2281754d5c5664fc92bc97710c5", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs" + }, + { + "blob": "482151f9ed085819fc82bbe85df003beec21ed02", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs" + }, + { + "blob": "b60e95a076611d3661fef95091f041ba228d546e", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs" + }, + { + "blob": "b93a52759704651ccb7d09d946c0900c8ab46e54", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs" + }, + { + "blob": "48b0accda29b02366d4f652b5c05c2ee7956f6d2", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs" + }, + { + "blob": "77cc02f8920b8ac424dd0854d2a1ec188329a01b", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs" + }, + { + "blob": "0d862db009407131da16a23b1cc255d3155a64b2", + "path": "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs" + }, + { + "blob": "28a89ec5ee3eb48673ec895f3bd0f8404ec29e99", + "path": "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs" + }, + { + "blob": "faf7be2c04decc1a966a5870e0641ec47d72da5c", + "path": "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs" + }, + { + "blob": "87f06ebe8d6842ec1011a0c8e935c92fd47ee714", + "path": "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs" + }, + { + "blob": "1faa3a7b8fa19ae08128e1b1f30d6dfae1e9f534", + "path": "corpus/real-world/ado-executereader-leak/after.cs" + }, + { + "blob": "d69020eceb2c3619ce3d2f6f36715d97aad5b616", + "path": "corpus/real-world/ado-executereader-leak/before.cs" + }, + { + "blob": "d36d794ecd78e95a99964ecd5ff4e66cc1352e43", + "path": "corpus/real-world/arraypool-aliased-receiver/after.cs" + }, + { + "blob": "3ee0cbfd662aec91a0c437ade04ef9f5a885280a", + "path": "corpus/real-world/arraypool-aliased-receiver/before.cs" + }, + { + "blob": "9c319b50c8147b72a07f2c4c643c936d9849e35c", + "path": "corpus/real-world/arraypool-double-return/after.cs" + }, + { + "blob": "9dc6c22a359a922ea104e2babd1f6c3cb18c55aa", + "path": "corpus/real-world/arraypool-double-return/before.cs" + }, + { + "blob": "fa9fce58d4d9f62a37ab0cd5b88b49627b6e2553", + "path": "corpus/real-world/arraypool-field-fullspan-overread/after.cs" + }, + { + "blob": "768af16266ec428afdb343185a654138d1d04d71", + "path": "corpus/real-world/arraypool-field-fullspan-overread/before.cs" + }, + { + "blob": "3c45a05482eae50f6c68f806e80e1bd030f30151", + "path": "corpus/real-world/arraypool-fullspan-overread/after.cs" + }, + { + "blob": "991b898ca1f564320ee3f5b9eba69e56b5607f6d", + "path": "corpus/real-world/arraypool-fullspan-overread/before.cs" + }, + { + "blob": "8f1c0de961065338fa611e1ac2b3e93099d1a390", + "path": "corpus/real-world/arraypool-length-overread/after.cs" + }, + { + "blob": "0c7d64c1159b4041118b674a912a7f5533e8a301", + "path": "corpus/real-world/arraypool-length-overread/before.cs" + }, + { + "blob": "8c8794e57d810cd542d90c12cea06ff1c034a0fc", + "path": "corpus/real-world/arraypool-memory-view-escape/after.cs" + }, + { + "blob": "7a29e26ef81bc82f98b5c19f626ead25de43986e", + "path": "corpus/real-world/arraypool-memory-view-escape/before.cs" + }, + { + "blob": "debff6f8435c5f396cd1b00d9c12cf09102d13f9", + "path": "corpus/real-world/arraypool-span-view-after-return/after.cs" + }, + { + "blob": "818d3c8cba0b5dbcc9cec5993322d2e04c840f17", + "path": "corpus/real-world/arraypool-span-view-after-return/before.cs" + }, + { + "blob": "708735216525a12901b06cce249aa65f37b5da6b", + "path": "corpus/real-world/arraypool-use-after-return/after.cs" + }, + { + "blob": "0506cd9adcf09ac17e98c56d713d33b516a791af", + "path": "corpus/real-world/arraypool-use-after-return/before.cs" + }, + { + "blob": "6ec2e76f1070f5a1fa3942e11f7e5e5009fe7a03", + "path": "corpus/real-world/arraypool-view-into-field-overread/after.cs" + }, + { + "blob": "5c72fc7284fec7a262a66a499e3197cc663771ac", + "path": "corpus/real-world/arraypool-view-into-field-overread/before.cs" + }, + { + "blob": "02e54d36919c8d03bce56321faa1f7efabb981f9", + "path": "corpus/real-world/field-dispose-via-exchange/after.cs" + }, + { + "blob": "b532135df2f7946e70829834444059b840a168f5", + "path": "corpus/real-world/field-dispose-via-exchange/before.cs" + }, + { + "blob": "c9b071d49cbddd567a108425de4cd7803886b1c6", + "path": "corpus/real-world/field-dispose-via-helper/after.cs" + }, + { + "blob": "7d232b848ef85fbb55deafaff024084a857d7edd", + "path": "corpus/real-world/field-dispose-via-helper/before.cs" + }, + { + "blob": "a07539757bc6bf6ae24766092f56f72ca7bf3010", + "path": "corpus/real-world/field-noop-dispose-wrapper/after.cs" + }, + { + "blob": "8fd5c820e25bab6682f5b02e43b562d2305410a3", + "path": "corpus/real-world/field-noop-dispose-wrapper/before.cs" + }, + { + "blob": "135a360400f5da99bcf6ba5a2efcd1413833e868", + "path": "corpus/real-world/local-dispose-via-using-statement/after.cs" + }, + { + "blob": "5c93e81a1c4bc7b43fd9493a73d2227926d6c069", + "path": "corpus/real-world/local-dispose-via-using-statement/before.cs" + }, + { + "blob": "c7d52d6ead47c013d221e5a3406b98044ced70a2", + "path": "corpus/real-world/memorypool-double-dispose/after.cs" + }, + { + "blob": "b0a3acd9dced8ea7f2bb4702e92984e2be53f931", + "path": "corpus/real-world/memorypool-double-dispose/before.cs" + }, + { + "blob": "51f5e21473f3831892c82e8b35277dc91108bdcf", + "path": "corpus/real-world/memorypool-using-owner-escape/after.cs" + }, + { + "blob": "bfc1b768c48074d67f7da744a2cfd1e58b77be06", + "path": "corpus/real-world/memorypool-using-owner-escape/before.cs" + }, + { + "blob": "2466da9d86248686070994b434beca526c51fe06", + "path": "corpus/real-world/memorypool-using-statement-view-escape/after.cs" + }, + { + "blob": "afc9ea74b3e8c407c06d7a797ba3673a926f5c3c", + "path": "corpus/real-world/memorypool-using-statement-view-escape/before.cs" + }, + { + "blob": "499ce51f09325341ddbbb8236944fa9bc2158eac", + "path": "corpus/real-world/memorypool-using-view-escape/after.cs" + }, + { + "blob": "45437c15fa6ec4e2b5f28f16cfc41155866f00ae", + "path": "corpus/real-world/memorypool-using-view-escape/before.cs" + }, + { + "blob": "7327ffa1666b4ba534fbb9a3f0d5f9d4a9e1b628", + "path": "corpus/real-world/memorypool-view-after-dispose/after.cs" + }, + { + "blob": "072dfa923df7e919913fc69e0d676e5ce2ebafa5", + "path": "corpus/real-world/memorypool-view-after-dispose/before.cs" + }, + { + "blob": "78eb173af727d40d4477ebb313cfcbf5291068c2", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs" + }, + { + "blob": "a4deffc410b2dedfc5edb61cec3ef6f1777d0adf", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs" + }, + { + "blob": "f2a81599a30d95c539b3918aeef3d4213e50c721", + "path": "corpus/real-world/ownership-handoff-consume/after.cs" + }, + { + "blob": "d65ba7b9424e36eb2c5e7e8fc7b390bdb2f6bfff", + "path": "corpus/real-world/ownership-handoff-consume/before.cs" + }, + { + "blob": "91134e9bd2cc709b0174e20c31e43b76b297df66", + "path": "corpus/real-world/ownership-handoff-use-transitive/after.cs" + }, + { + "blob": "2ed2ca15dfdea27d0f1a072d3b569eea7596b0b1", + "path": "corpus/real-world/ownership-handoff-use-transitive/before.cs" + }, + { + "blob": "8aacb78586d8441ea060a6fcac1590bb7c4e824e", + "path": "corpus/real-world/ownership-handoff-use/after.cs" + }, + { + "blob": "e4a61bf6023f4e32f54a1c4887e26c844f757f42", + "path": "corpus/real-world/ownership-handoff-use/before.cs" + }, + { + "blob": "a4f71bc85fc6219e309a7ffb2fe4659c7ba647cd", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/after.cs" + }, + { + "blob": "004dfda6385ff8697c8c16aeb844bcfb46ca9a2a", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/before.cs" + }, + { + "blob": "48fea235d362012f5482abbe598a69ba513f598a", + "path": "corpus/real-world/screentogif-loaded-subscription/after.cs" + }, + { + "blob": "f531ea536868381417fef0d8392bf956802ea194", + "path": "corpus/real-world/screentogif-loaded-subscription/before.cs" + }, + { + "blob": "f353a95c721347d12317acd7ea4b089495c9ec1a", + "path": "corpus/real-world/screentogif-systemevents-leak/after.cs" + }, + { + "blob": "f531e57e99f32029d1ae7b3df183c2785ef85714", + "path": "corpus/real-world/screentogif-systemevents-leak/before.cs" + }, + { + "blob": "671e8c665df0f4a951fd14002b056355b37019ea", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs" + }, + { + "blob": "09dbfd123416af89eff3f8e301ec300f184a2d8d", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs" + }, + { + "blob": "37eabf992f0e083364d20160a1ddf0c82c28b768", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs" + }, + { + "blob": "2355f37e9fc8fc6b63e5023a2a2a18265b16d669", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs" + }, + { + "blob": "74a99ffd338ef3cbf853cf2804c3a3ece8ed42a7", + "path": "corpus/real-world/socket-accept-leak/after.cs" + }, + { + "blob": "18a721ce6d07b7eed6cf97afef578d97e7ba2744", + "path": "corpus/real-world/socket-accept-leak/before.cs" + }, + { + "blob": "3be8156197c7e76fe60eee06028c65fe03407254", + "path": "corpus/real-world/subscription-self-owned-property/after.cs" + }, + { + "blob": "53ec5ba89ca9eb3791bcc7c2489c5884dd0acad7", + "path": "corpus/real-world/subscription-self-owned-property/before.cs" + }, + { + "blob": "601976e5600d97d6184fe5dc44b957c985a97115", + "path": "corpus/real-world/tcplistener-accept-leak/after.cs" + }, + { + "blob": "ab88672d4e90e99b7a8fb2a061d533a5a5ef0072", + "path": "corpus/real-world/tcplistener-accept-leak/before.cs" + }, + { + "blob": "dce3d96a463068f59288176541d5c75befa570b8", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/after.cs" + }, + { + "blob": "6ae9c4c8faef9559b9ac4de4da1ba03c4acada5e", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/before.cs" + }, + { + "blob": "b54a2b87b1f584a9a857c5f311d5874099910643", + "path": "corpus/real-world/using-statement-throw-releases/after.cs" + }, + { + "blob": "acc415ddf95c058de642d3a13e39226570ebf6e0", + "path": "corpus/real-world/using-statement-throw-releases/before.cs" + }, + { + "blob": "ef464e6cf0f0bb0c9d3941fa0fce881b78011bcb", + "path": "corpus/wpf/custom-weak-wrapper/after.cs" + }, + { + "blob": "d255613e1dbf311f93c34cbabc1ae304b648ea2b", + "path": "corpus/wpf/custom-weak-wrapper/before.cs" + }, + { + "blob": "30697c7b21435ea03352b9f1826938c88a60d3d9", + "path": "corpus/wpf/field-use-after-dispose/after.cs" + }, + { + "blob": "79fdb97a6375c5b1b6df5be6967bd22c738e9cce", + "path": "corpus/wpf/field-use-after-dispose/before.cs" + }, + { + "blob": "242fec8ebaf85ea83df4a0a27c9f1e6cac80a9b8", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs" + }, + { + "blob": "445968e5bc0d6bb77950196774b5f645c6d56459", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs" + }, + { + "blob": "2aaf3b53fba9dd98a72cbe7c2caed65cf89262fd", + "path": "corpus/wpf/handler-use-after-dispose/after.cs" + }, + { + "blob": "68e25c6b763c122df627b3e7847f548524db9d21", + "path": "corpus/wpf/handler-use-after-dispose/before.cs" + }, + { + "blob": "b62ced3b658f10929e98d5fca7c65401b4fc0aea", + "path": "corpus/wpf/pooled-view-after-dispose/after.cs" + }, + { + "blob": "4731249cfee1b47a750fbc11ac66b598b17453ae", + "path": "corpus/wpf/pooled-view-after-dispose/before.cs" + }, + { + "blob": "9b093f5e39f7087333b7f8f2c89a4b155e078edd", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs" + }, + { + "blob": "e7d5904e1c32d78a267309faf6717be59a374aec", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs" + }, + { + "blob": "cb3ed69a917c9516ddcafa5c7c55cc8467739fe5", + "path": "corpus/wpf/subscription-disposing-else-branch-release/after.cs" + }, + { + "blob": "d0e1dc7929300bc60f4349a7e0df29ca87d018ce", + "path": "corpus/wpf/subscription-disposing-else-branch-release/before.cs" + }, + { + "blob": "bae861a35a441a2fc7714d9904883bd576182ed4", + "path": "corpus/wpf/subscription-explicit-delegate-release/after.cs" + }, + { + "blob": "e86bb4d5ff49116c6fd49c045b7d4f5136add534", + "path": "corpus/wpf/subscription-explicit-delegate-release/before.cs" + }, + { + "blob": "8299b26e3d1d9ec7c15673ba148199aafac6c6ef", + "path": "corpus/wpf/subscription-finalizer-release/after.cs" + }, + { + "blob": "3d03e2c90b8c8cacd68ef93cf44587f3d299288d", + "path": "corpus/wpf/subscription-finalizer-release/before.cs" + }, + { + "blob": "622e8cd997b9d2acf731c3b415166568339adf3a", + "path": "corpus/wpf/subscription-nonteardown-release/after.cs" + }, + { + "blob": "54f7969790b8daa82b498f795e1341e63fc1dd89", + "path": "corpus/wpf/subscription-nonteardown-release/before.cs" + }, + { + "blob": "934577f5c5c294d77029d816908b69f276c6583c", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/after.cs" + }, + { + "blob": "1a0462ebd958a6e7d1a23dae2b8c99a1fdf48700", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/before.cs" + }, + { + "blob": "b1b9faf7f5ce931bc89316e239ec03b482cc6700", + "path": "corpus/wpf/subscription-param-guarded-unregister/after.cs" + }, + { + "blob": "015343c46671afe384fd1a60d38c107426a01420", + "path": "corpus/wpf/subscription-param-guarded-unregister/before.cs" + }, + { + "blob": "f57d5340e25a55538de23892e29c1718d3042e8f", + "path": "corpus/wpf/subscription-target-typed-delegate-release/after.cs" + }, + { + "blob": "b6ada87556cf82ab68f6c58afdfec9d85daa93ef", + "path": "corpus/wpf/subscription-target-typed-delegate-release/before.cs" + }, + { + "blob": "0cab64b233266ef06e6988f27326eded395271e3", + "path": "corpus/wpf/subscription-teardown-early-return-guard/after.cs" + }, + { + "blob": "85d32821de0a02990a5e1abf87eccc986bac6b93", + "path": "corpus/wpf/subscription-teardown-early-return-guard/before.cs" + }, + { + "blob": "23bd620a57b1a68d0cf6569125817caf3fb47efc", + "path": "corpus/wpf/subscription-uncalled-local-function/after.cs" + }, + { + "blob": "2e129b6bb1e183443a073bf083a3a04b844d9a98", + "path": "corpus/wpf/subscription-uncalled-local-function/before.cs" + }, + { + "blob": "292c674a95a34ddff1f9eace96bbd316dabafff5", + "path": "corpus/wpf/subscription-xaml-name-only-release/after.cs" + }, + { + "blob": "59c8548878d13a026de9ddc65534b38ae94f8864", + "path": "corpus/wpf/subscription-xaml-name-only-release/before.cs" + }, + { + "blob": "3062b7e371fb709c622ef5ac918f4682df990b3b", + "path": "corpus/wpf/systemevents-region-escape/after.cs" + }, + { + "blob": "5a89237790ae5b12d64a680288196c6ead8c6662", + "path": "corpus/wpf/systemevents-region-escape/before.cs" + }, + { + "blob": "4ab388af8e8ea1b1faaf154f0f878db498fce704", + "path": "corpus/wpf/timer-stop-disposing-else-branch/after.cs" + }, + { + "blob": "5c1a7e991a861b316bf08869ef425583d26da556", + "path": "corpus/wpf/timer-stop-disposing-else-branch/before.cs" + }, + { + "blob": "a8a4d710a2f06c25e43a106c1410800369696d74", + "path": "corpus/wpf/timer-stop-early-return-guard/after.cs" + }, + { + "blob": "2e8e5e241d7980c65a70857fa128400c23331fed", + "path": "corpus/wpf/timer-stop-early-return-guard/before.cs" + }, + { + "blob": "743a4fab56737068377dbc553a030cc87273a465", + "path": "corpus/wpf/timer-stop-finalizer-release/after.cs" + }, + { + "blob": "973df1396ee32098c045e55dff973b979f13c1fc", + "path": "corpus/wpf/timer-stop-finalizer-release/before.cs" + }, + { + "blob": "d8e77d9849476e5491b4dcc19a9e53e48ff39795", + "path": "corpus/wpf/timer-stop-nonteardown-release/after.cs" + }, + { + "blob": "a2b1699fa2ce74a8bfab34c8d63a2374a9696723", + "path": "corpus/wpf/timer-stop-nonteardown-release/before.cs" + }, + { + "blob": "d59b693ecf990fd43d60a1051544f40e1ad2c818", + "path": "corpus/wpf/timer-stop-param-guarded/after.cs" + }, + { + "blob": "012854a1e19f04133dc78ecbbd14a1cef8044622", + "path": "corpus/wpf/timer-stop-param-guarded/before.cs" + }, + { + "blob": "e76351d486fd80e1037a4bca2ab9783c7ae4c1fd", + "path": "corpus/wpf/timer-stop-uncalled-helper/after.cs" + }, + { + "blob": "42a743ff9743fd38551eaf687b0a96ac874f0eb8", + "path": "corpus/wpf/timer-stop-uncalled-helper/before.cs" + }, + { + "blob": "0a65c2215f03fc979d71d4f91458043e2b02a143", + "path": "corpus/wpf/timer-stop-uncalled-lambda/after.cs" + }, + { + "blob": "3c29d5f0fe3f49b79244fd482e18bc9a39b1bb52", + "path": "corpus/wpf/timer-stop-uncalled-lambda/before.cs" + }, + { + "blob": "39bef7650422dfbac6319adbf0a82a99105a9ee6", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/after.cs" + }, + { + "blob": "0d5062f2477f382150b32b286aa8726e51170200", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/before.cs" + }, + { + "blob": "b2b6b657b0da7947086911cd2833278e1ca926c2", + "path": "corpus/wpf/timer-stop-wrong-receiver/after.cs" + }, + { + "blob": "d781717509873e414e92801419decddb32e0f826", + "path": "corpus/wpf/timer-stop-wrong-receiver/before.cs" + }, + { + "blob": "82f57d8b91534fd08c54f1b1f0857c3f8c76d46e", + "path": "corpus/wpf/viewmodel-escapes-to-app/after.cs" + }, + { + "blob": "ae52b324a6e428015fc5974bd11d60f8bfe3e4d0", + "path": "corpus/wpf/viewmodel-escapes-to-app/before.cs" + }, + { + "blob": "1f96bb7c57b978ff329761ca730a7d975b39fba9", + "path": "corpus/wpf/zombie-viewmodel/after.cs" + }, + { + "blob": "e9e4d0700a5abff8114dbe619993069b05bd6fc2", + "path": "corpus/wpf/zombie-viewmodel/before.cs" + } + ], + "analysis_manifest_sha256": "97ea59f4b4e7409597cdc00bf0e7d6496397b5c24f8c7785a063c507a23d5397", + "artifacts": {}, + "corpus": [ + "corpus/real-world", + "corpus/wpf", + "corpus/di", + "corpus/fixtures", + "corpus/p036-bakeoff" + ], + "dirty": false, + "engine": "python", + "execution_profile": { + "dotnet": { + "runtimes": [ + "Microsoft.AspNetCore.App 8.0.31", + "Microsoft.NETCore.App 8.0.31" + ], + "sdk": "8.0.425" + }, + "platform": { + "machine": "x86_64", + "system": "Linux" + }, + "python": { + "implementation": "CPython", + "version": "3.11.15 (main, Sep 19 2026, 00:18:08) [GCC 16.1.1 20260625]" + } + }, + "files": { + "corpus/di/singleton-captures-scoped-dbcontext/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/di/singleton-captures-scoped-dbcontext/before.cs": { + "exit": 0, + "findings": [ + { + "code": "DI001", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/fixtures/systemevents-console/Program.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 43 + }, + { + "code": "OWN001", + "level": "warning", + "line": 54 + }, + { + "code": "OWN001", + "level": "warning", + "line": 77 + } + ] + }, + "corpus/p036-bakeoff/guarded-consume-early-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-early-return/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 28 + } + ] + }, + "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 38 + } + ] + }, + "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 35 + } + ] + }, + "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ado-executereader-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ado-executereader-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 11 + } + ] + }, + "corpus/real-world/arraypool-aliased-receiver/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-aliased-receiver/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/arraypool-double-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-double-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/real-world/arraypool-field-fullspan-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-field-fullspan-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 40 + }, + { + "code": "OWN025", + "level": "warning", + "line": 46 + } + ] + }, + "corpus/real-world/arraypool-fullspan-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-fullspan-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 24 + }, + { + "code": "OWN025", + "level": "warning", + "line": 26 + } + ] + }, + "corpus/real-world/arraypool-length-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-length-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/real-world/arraypool-memory-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-memory-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/arraypool-span-view-after-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-span-view-after-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/arraypool-use-after-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-use-after-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/real-world/arraypool-view-into-field-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-view-into-field-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 40 + }, + { + "code": "OWN025", + "level": "warning", + "line": 41 + } + ] + }, + "corpus/real-world/field-dispose-via-exchange/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-dispose-via-exchange/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/real-world/field-dispose-via-helper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-dispose-via-helper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/field-noop-dispose-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-noop-dispose-wrapper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 9 + } + ] + }, + "corpus/real-world/local-dispose-via-using-statement/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/local-dispose-via-using-statement/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/real-world/memorypool-double-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-double-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-owner-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-owner-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-statement-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-statement-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/real-world/memorypool-view-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-view-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/real-world/ownership-handoff-consume/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-consume/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN002", + "level": "warning", + "line": 28 + } + ] + }, + "corpus/real-world/ownership-handoff-use-transitive/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-use-transitive/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/real-world/ownership-handoff-use/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-use/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 22 + } + ] + }, + "corpus/real-world/pool-transfer-via-wrapper-local/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/pool-transfer-via-wrapper-local/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/screentogif-loaded-subscription/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 21 + } + ] + }, + "corpus/real-world/screentogif-loaded-subscription/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 24 + }, + { + "code": "OWN001", + "level": "warning", + "line": 25 + }, + { + "code": "OWN001", + "level": "warning", + "line": 26 + } + ] + }, + "corpus/real-world/screentogif-systemevents-leak/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 12 + }, + { + "code": "OWN050", + "level": "note", + "line": 13 + } + ] + }, + "corpus/real-world/screentogif-systemevents-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + } + ] + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 24 + }, + { + "code": "OWN001", + "level": "warning", + "line": 27 + } + ] + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/socket-accept-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/socket-accept-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 10 + } + ] + }, + "corpus/real-world/subscription-self-owned-property/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/subscription-self-owned-property/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/tcplistener-accept-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/tcplistener-accept-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 11 + } + ] + }, + "corpus/real-world/tcplistener-acceptsocket-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/tcplistener-acceptsocket-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 10 + } + ] + }, + "corpus/real-world/using-statement-throw-releases/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/using-statement-throw-releases/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/wpf/custom-weak-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/custom-weak-wrapper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 13 + } + ] + }, + "corpus/wpf/field-use-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/field-use-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/wpf/handler-use-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/handler-use-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/pooled-view-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/pooled-view-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + } + ] + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 26 + }, + { + "code": "OWN050", + "level": "note", + "line": 27 + } + ] + }, + "corpus/wpf/subscription-disposing-else-branch-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-disposing-else-branch-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 25 + } + ] + }, + "corpus/wpf/subscription-explicit-delegate-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-explicit-delegate-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/wpf/subscription-finalizer-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-finalizer-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 22 + } + ] + }, + "corpus/wpf/subscription-nonteardown-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-nonteardown-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/wpf/subscription-overload-conflated-cleanup/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-overload-conflated-cleanup/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/wpf/subscription-param-guarded-unregister/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-param-guarded-unregister/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 25 + } + ] + }, + "corpus/wpf/subscription-target-typed-delegate-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-target-typed-delegate-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 14 + } + ] + }, + "corpus/wpf/subscription-teardown-early-return-guard/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-teardown-early-return-guard/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/wpf/subscription-uncalled-local-function/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-uncalled-local-function/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 42 + } + ] + }, + "corpus/wpf/subscription-xaml-name-only-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-xaml-name-only-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/wpf/systemevents-region-escape/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 15 + }, + { + "code": "OWN050", + "level": "note", + "line": 16 + } + ] + }, + "corpus/wpf/systemevents-region-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 26 + } + ] + }, + "corpus/wpf/timer-stop-disposing-else-branch/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-disposing-else-branch/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/wpf/timer-stop-early-return-guard/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-early-return-guard/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/wpf/timer-stop-finalizer-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-finalizer-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-nonteardown-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-nonteardown-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/wpf/timer-stop-param-guarded/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-param-guarded/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-uncalled-helper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-uncalled-helper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-uncalled-lambda/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-uncalled-lambda/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-unwired-lifecycle/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-unwired-lifecycle/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-wrong-receiver/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-wrong-receiver/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 16 + } + ] + }, + "corpus/wpf/viewmodel-escapes-to-app/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/viewmodel-escapes-to-app/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 14 + } + ] + }, + "corpus/wpf/zombie-viewmodel/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/zombie-viewmodel/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 13 + } + ] + } + }, + "input_roots": [ + "corpus/real-world", + "corpus/wpf", + "corpus/di", + "corpus/fixtures", + "corpus/p036-bakeoff" + ], + "instrument_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py" + ], + "is_evidence": true, + "materialization_root": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095", + "population_commit": "4a8e6582e10222403cd40adc9e95db7e0228a1c2", + "post_run_population_intact": true, + "reference_profile": { + "OWN_EXTRA_REF_DIRS": "removed-from-child-environment", + "observed_extra_reference_lines": 0 + }, + "schema": "p037-verdict-snapshot/3", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2", + "subject_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py", + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ], + "support_manifest": [], + "support_manifest_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "treatment_paths": [ + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ] +} diff --git a/docs/evidence/p037-a2.1-after-verdict-rust.json b/docs/evidence/p037-a2.1-after-verdict-rust.json new file mode 100644 index 00000000..147ac193 --- /dev/null +++ b/docs/evidence/p037-a2.1-after-verdict-rust.json @@ -0,0 +1,1709 @@ +{ + "analysis_manifest": [ + { + "blob": "38d180096c63c7d01d7bb39601c1f88e3a53f67e", + "path": "corpus/di/singleton-captures-scoped-dbcontext/after.cs" + }, + { + "blob": "4d6f60e065d7e2572bc457e3df6a593b6a4699c4", + "path": "corpus/di/singleton-captures-scoped-dbcontext/before.cs" + }, + { + "blob": "67c4aa0b15fa0782d865cbd1c5ef355fbc926f8f", + "path": "corpus/fixtures/systemevents-console/Program.cs" + }, + { + "blob": "c9d140949acfe06bd187404508a46b6b61a7c89e", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/after.cs" + }, + { + "blob": "c80dee0bc66037c3c4ae7ff8ce8125ba145f8156", + "path": "corpus/p036-bakeoff/guarded-consume-early-return/before.cs" + }, + { + "blob": "b13ab3891e11f2281754d5c5664fc92bc97710c5", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs" + }, + { + "blob": "482151f9ed085819fc82bbe85df003beec21ed02", + "path": "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs" + }, + { + "blob": "b60e95a076611d3661fef95091f041ba228d546e", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs" + }, + { + "blob": "b93a52759704651ccb7d09d946c0900c8ab46e54", + "path": "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs" + }, + { + "blob": "48b0accda29b02366d4f652b5c05c2ee7956f6d2", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs" + }, + { + "blob": "77cc02f8920b8ac424dd0854d2a1ec188329a01b", + "path": "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs" + }, + { + "blob": "0d862db009407131da16a23b1cc255d3155a64b2", + "path": "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs" + }, + { + "blob": "28a89ec5ee3eb48673ec895f3bd0f8404ec29e99", + "path": "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs" + }, + { + "blob": "faf7be2c04decc1a966a5870e0641ec47d72da5c", + "path": "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs" + }, + { + "blob": "87f06ebe8d6842ec1011a0c8e935c92fd47ee714", + "path": "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs" + }, + { + "blob": "1faa3a7b8fa19ae08128e1b1f30d6dfae1e9f534", + "path": "corpus/real-world/ado-executereader-leak/after.cs" + }, + { + "blob": "d69020eceb2c3619ce3d2f6f36715d97aad5b616", + "path": "corpus/real-world/ado-executereader-leak/before.cs" + }, + { + "blob": "d36d794ecd78e95a99964ecd5ff4e66cc1352e43", + "path": "corpus/real-world/arraypool-aliased-receiver/after.cs" + }, + { + "blob": "3ee0cbfd662aec91a0c437ade04ef9f5a885280a", + "path": "corpus/real-world/arraypool-aliased-receiver/before.cs" + }, + { + "blob": "9c319b50c8147b72a07f2c4c643c936d9849e35c", + "path": "corpus/real-world/arraypool-double-return/after.cs" + }, + { + "blob": "9dc6c22a359a922ea104e2babd1f6c3cb18c55aa", + "path": "corpus/real-world/arraypool-double-return/before.cs" + }, + { + "blob": "fa9fce58d4d9f62a37ab0cd5b88b49627b6e2553", + "path": "corpus/real-world/arraypool-field-fullspan-overread/after.cs" + }, + { + "blob": "768af16266ec428afdb343185a654138d1d04d71", + "path": "corpus/real-world/arraypool-field-fullspan-overread/before.cs" + }, + { + "blob": "3c45a05482eae50f6c68f806e80e1bd030f30151", + "path": "corpus/real-world/arraypool-fullspan-overread/after.cs" + }, + { + "blob": "991b898ca1f564320ee3f5b9eba69e56b5607f6d", + "path": "corpus/real-world/arraypool-fullspan-overread/before.cs" + }, + { + "blob": "8f1c0de961065338fa611e1ac2b3e93099d1a390", + "path": "corpus/real-world/arraypool-length-overread/after.cs" + }, + { + "blob": "0c7d64c1159b4041118b674a912a7f5533e8a301", + "path": "corpus/real-world/arraypool-length-overread/before.cs" + }, + { + "blob": "8c8794e57d810cd542d90c12cea06ff1c034a0fc", + "path": "corpus/real-world/arraypool-memory-view-escape/after.cs" + }, + { + "blob": "7a29e26ef81bc82f98b5c19f626ead25de43986e", + "path": "corpus/real-world/arraypool-memory-view-escape/before.cs" + }, + { + "blob": "debff6f8435c5f396cd1b00d9c12cf09102d13f9", + "path": "corpus/real-world/arraypool-span-view-after-return/after.cs" + }, + { + "blob": "818d3c8cba0b5dbcc9cec5993322d2e04c840f17", + "path": "corpus/real-world/arraypool-span-view-after-return/before.cs" + }, + { + "blob": "708735216525a12901b06cce249aa65f37b5da6b", + "path": "corpus/real-world/arraypool-use-after-return/after.cs" + }, + { + "blob": "0506cd9adcf09ac17e98c56d713d33b516a791af", + "path": "corpus/real-world/arraypool-use-after-return/before.cs" + }, + { + "blob": "6ec2e76f1070f5a1fa3942e11f7e5e5009fe7a03", + "path": "corpus/real-world/arraypool-view-into-field-overread/after.cs" + }, + { + "blob": "5c72fc7284fec7a262a66a499e3197cc663771ac", + "path": "corpus/real-world/arraypool-view-into-field-overread/before.cs" + }, + { + "blob": "02e54d36919c8d03bce56321faa1f7efabb981f9", + "path": "corpus/real-world/field-dispose-via-exchange/after.cs" + }, + { + "blob": "b532135df2f7946e70829834444059b840a168f5", + "path": "corpus/real-world/field-dispose-via-exchange/before.cs" + }, + { + "blob": "c9b071d49cbddd567a108425de4cd7803886b1c6", + "path": "corpus/real-world/field-dispose-via-helper/after.cs" + }, + { + "blob": "7d232b848ef85fbb55deafaff024084a857d7edd", + "path": "corpus/real-world/field-dispose-via-helper/before.cs" + }, + { + "blob": "a07539757bc6bf6ae24766092f56f72ca7bf3010", + "path": "corpus/real-world/field-noop-dispose-wrapper/after.cs" + }, + { + "blob": "8fd5c820e25bab6682f5b02e43b562d2305410a3", + "path": "corpus/real-world/field-noop-dispose-wrapper/before.cs" + }, + { + "blob": "135a360400f5da99bcf6ba5a2efcd1413833e868", + "path": "corpus/real-world/local-dispose-via-using-statement/after.cs" + }, + { + "blob": "5c93e81a1c4bc7b43fd9493a73d2227926d6c069", + "path": "corpus/real-world/local-dispose-via-using-statement/before.cs" + }, + { + "blob": "c7d52d6ead47c013d221e5a3406b98044ced70a2", + "path": "corpus/real-world/memorypool-double-dispose/after.cs" + }, + { + "blob": "b0a3acd9dced8ea7f2bb4702e92984e2be53f931", + "path": "corpus/real-world/memorypool-double-dispose/before.cs" + }, + { + "blob": "51f5e21473f3831892c82e8b35277dc91108bdcf", + "path": "corpus/real-world/memorypool-using-owner-escape/after.cs" + }, + { + "blob": "bfc1b768c48074d67f7da744a2cfd1e58b77be06", + "path": "corpus/real-world/memorypool-using-owner-escape/before.cs" + }, + { + "blob": "2466da9d86248686070994b434beca526c51fe06", + "path": "corpus/real-world/memorypool-using-statement-view-escape/after.cs" + }, + { + "blob": "afc9ea74b3e8c407c06d7a797ba3673a926f5c3c", + "path": "corpus/real-world/memorypool-using-statement-view-escape/before.cs" + }, + { + "blob": "499ce51f09325341ddbbb8236944fa9bc2158eac", + "path": "corpus/real-world/memorypool-using-view-escape/after.cs" + }, + { + "blob": "45437c15fa6ec4e2b5f28f16cfc41155866f00ae", + "path": "corpus/real-world/memorypool-using-view-escape/before.cs" + }, + { + "blob": "7327ffa1666b4ba534fbb9a3f0d5f9d4a9e1b628", + "path": "corpus/real-world/memorypool-view-after-dispose/after.cs" + }, + { + "blob": "072dfa923df7e919913fc69e0d676e5ce2ebafa5", + "path": "corpus/real-world/memorypool-view-after-dispose/before.cs" + }, + { + "blob": "78eb173af727d40d4477ebb313cfcbf5291068c2", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs" + }, + { + "blob": "a4deffc410b2dedfc5edb61cec3ef6f1777d0adf", + "path": "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs" + }, + { + "blob": "f2a81599a30d95c539b3918aeef3d4213e50c721", + "path": "corpus/real-world/ownership-handoff-consume/after.cs" + }, + { + "blob": "d65ba7b9424e36eb2c5e7e8fc7b390bdb2f6bfff", + "path": "corpus/real-world/ownership-handoff-consume/before.cs" + }, + { + "blob": "91134e9bd2cc709b0174e20c31e43b76b297df66", + "path": "corpus/real-world/ownership-handoff-use-transitive/after.cs" + }, + { + "blob": "2ed2ca15dfdea27d0f1a072d3b569eea7596b0b1", + "path": "corpus/real-world/ownership-handoff-use-transitive/before.cs" + }, + { + "blob": "8aacb78586d8441ea060a6fcac1590bb7c4e824e", + "path": "corpus/real-world/ownership-handoff-use/after.cs" + }, + { + "blob": "e4a61bf6023f4e32f54a1c4887e26c844f757f42", + "path": "corpus/real-world/ownership-handoff-use/before.cs" + }, + { + "blob": "a4f71bc85fc6219e309a7ffb2fe4659c7ba647cd", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/after.cs" + }, + { + "blob": "004dfda6385ff8697c8c16aeb844bcfb46ca9a2a", + "path": "corpus/real-world/pool-transfer-via-wrapper-local/before.cs" + }, + { + "blob": "48fea235d362012f5482abbe598a69ba513f598a", + "path": "corpus/real-world/screentogif-loaded-subscription/after.cs" + }, + { + "blob": "f531ea536868381417fef0d8392bf956802ea194", + "path": "corpus/real-world/screentogif-loaded-subscription/before.cs" + }, + { + "blob": "f353a95c721347d12317acd7ea4b089495c9ec1a", + "path": "corpus/real-world/screentogif-systemevents-leak/after.cs" + }, + { + "blob": "f531e57e99f32029d1ae7b3df183c2785ef85714", + "path": "corpus/real-world/screentogif-systemevents-leak/before.cs" + }, + { + "blob": "671e8c665df0f4a951fd14002b056355b37019ea", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs" + }, + { + "blob": "09dbfd123416af89eff3f8e301ec300f184a2d8d", + "path": "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs" + }, + { + "blob": "37eabf992f0e083364d20160a1ddf0c82c28b768", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs" + }, + { + "blob": "2355f37e9fc8fc6b63e5023a2a2a18265b16d669", + "path": "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs" + }, + { + "blob": "74a99ffd338ef3cbf853cf2804c3a3ece8ed42a7", + "path": "corpus/real-world/socket-accept-leak/after.cs" + }, + { + "blob": "18a721ce6d07b7eed6cf97afef578d97e7ba2744", + "path": "corpus/real-world/socket-accept-leak/before.cs" + }, + { + "blob": "3be8156197c7e76fe60eee06028c65fe03407254", + "path": "corpus/real-world/subscription-self-owned-property/after.cs" + }, + { + "blob": "53ec5ba89ca9eb3791bcc7c2489c5884dd0acad7", + "path": "corpus/real-world/subscription-self-owned-property/before.cs" + }, + { + "blob": "601976e5600d97d6184fe5dc44b957c985a97115", + "path": "corpus/real-world/tcplistener-accept-leak/after.cs" + }, + { + "blob": "ab88672d4e90e99b7a8fb2a061d533a5a5ef0072", + "path": "corpus/real-world/tcplistener-accept-leak/before.cs" + }, + { + "blob": "dce3d96a463068f59288176541d5c75befa570b8", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/after.cs" + }, + { + "blob": "6ae9c4c8faef9559b9ac4de4da1ba03c4acada5e", + "path": "corpus/real-world/tcplistener-acceptsocket-leak/before.cs" + }, + { + "blob": "b54a2b87b1f584a9a857c5f311d5874099910643", + "path": "corpus/real-world/using-statement-throw-releases/after.cs" + }, + { + "blob": "acc415ddf95c058de642d3a13e39226570ebf6e0", + "path": "corpus/real-world/using-statement-throw-releases/before.cs" + }, + { + "blob": "ef464e6cf0f0bb0c9d3941fa0fce881b78011bcb", + "path": "corpus/wpf/custom-weak-wrapper/after.cs" + }, + { + "blob": "d255613e1dbf311f93c34cbabc1ae304b648ea2b", + "path": "corpus/wpf/custom-weak-wrapper/before.cs" + }, + { + "blob": "30697c7b21435ea03352b9f1826938c88a60d3d9", + "path": "corpus/wpf/field-use-after-dispose/after.cs" + }, + { + "blob": "79fdb97a6375c5b1b6df5be6967bd22c738e9cce", + "path": "corpus/wpf/field-use-after-dispose/before.cs" + }, + { + "blob": "242fec8ebaf85ea83df4a0a27c9f1e6cac80a9b8", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs" + }, + { + "blob": "445968e5bc0d6bb77950196774b5f645c6d56459", + "path": "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs" + }, + { + "blob": "2aaf3b53fba9dd98a72cbe7c2caed65cf89262fd", + "path": "corpus/wpf/handler-use-after-dispose/after.cs" + }, + { + "blob": "68e25c6b763c122df627b3e7847f548524db9d21", + "path": "corpus/wpf/handler-use-after-dispose/before.cs" + }, + { + "blob": "b62ced3b658f10929e98d5fca7c65401b4fc0aea", + "path": "corpus/wpf/pooled-view-after-dispose/after.cs" + }, + { + "blob": "4731249cfee1b47a750fbc11ac66b598b17453ae", + "path": "corpus/wpf/pooled-view-after-dispose/before.cs" + }, + { + "blob": "9b093f5e39f7087333b7f8f2c89a4b155e078edd", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs" + }, + { + "blob": "e7d5904e1c32d78a267309faf6717be59a374aec", + "path": "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs" + }, + { + "blob": "cb3ed69a917c9516ddcafa5c7c55cc8467739fe5", + "path": "corpus/wpf/subscription-disposing-else-branch-release/after.cs" + }, + { + "blob": "d0e1dc7929300bc60f4349a7e0df29ca87d018ce", + "path": "corpus/wpf/subscription-disposing-else-branch-release/before.cs" + }, + { + "blob": "bae861a35a441a2fc7714d9904883bd576182ed4", + "path": "corpus/wpf/subscription-explicit-delegate-release/after.cs" + }, + { + "blob": "e86bb4d5ff49116c6fd49c045b7d4f5136add534", + "path": "corpus/wpf/subscription-explicit-delegate-release/before.cs" + }, + { + "blob": "8299b26e3d1d9ec7c15673ba148199aafac6c6ef", + "path": "corpus/wpf/subscription-finalizer-release/after.cs" + }, + { + "blob": "3d03e2c90b8c8cacd68ef93cf44587f3d299288d", + "path": "corpus/wpf/subscription-finalizer-release/before.cs" + }, + { + "blob": "622e8cd997b9d2acf731c3b415166568339adf3a", + "path": "corpus/wpf/subscription-nonteardown-release/after.cs" + }, + { + "blob": "54f7969790b8daa82b498f795e1341e63fc1dd89", + "path": "corpus/wpf/subscription-nonteardown-release/before.cs" + }, + { + "blob": "934577f5c5c294d77029d816908b69f276c6583c", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/after.cs" + }, + { + "blob": "1a0462ebd958a6e7d1a23dae2b8c99a1fdf48700", + "path": "corpus/wpf/subscription-overload-conflated-cleanup/before.cs" + }, + { + "blob": "b1b9faf7f5ce931bc89316e239ec03b482cc6700", + "path": "corpus/wpf/subscription-param-guarded-unregister/after.cs" + }, + { + "blob": "015343c46671afe384fd1a60d38c107426a01420", + "path": "corpus/wpf/subscription-param-guarded-unregister/before.cs" + }, + { + "blob": "f57d5340e25a55538de23892e29c1718d3042e8f", + "path": "corpus/wpf/subscription-target-typed-delegate-release/after.cs" + }, + { + "blob": "b6ada87556cf82ab68f6c58afdfec9d85daa93ef", + "path": "corpus/wpf/subscription-target-typed-delegate-release/before.cs" + }, + { + "blob": "0cab64b233266ef06e6988f27326eded395271e3", + "path": "corpus/wpf/subscription-teardown-early-return-guard/after.cs" + }, + { + "blob": "85d32821de0a02990a5e1abf87eccc986bac6b93", + "path": "corpus/wpf/subscription-teardown-early-return-guard/before.cs" + }, + { + "blob": "23bd620a57b1a68d0cf6569125817caf3fb47efc", + "path": "corpus/wpf/subscription-uncalled-local-function/after.cs" + }, + { + "blob": "2e129b6bb1e183443a073bf083a3a04b844d9a98", + "path": "corpus/wpf/subscription-uncalled-local-function/before.cs" + }, + { + "blob": "292c674a95a34ddff1f9eace96bbd316dabafff5", + "path": "corpus/wpf/subscription-xaml-name-only-release/after.cs" + }, + { + "blob": "59c8548878d13a026de9ddc65534b38ae94f8864", + "path": "corpus/wpf/subscription-xaml-name-only-release/before.cs" + }, + { + "blob": "3062b7e371fb709c622ef5ac918f4682df990b3b", + "path": "corpus/wpf/systemevents-region-escape/after.cs" + }, + { + "blob": "5a89237790ae5b12d64a680288196c6ead8c6662", + "path": "corpus/wpf/systemevents-region-escape/before.cs" + }, + { + "blob": "4ab388af8e8ea1b1faaf154f0f878db498fce704", + "path": "corpus/wpf/timer-stop-disposing-else-branch/after.cs" + }, + { + "blob": "5c1a7e991a861b316bf08869ef425583d26da556", + "path": "corpus/wpf/timer-stop-disposing-else-branch/before.cs" + }, + { + "blob": "a8a4d710a2f06c25e43a106c1410800369696d74", + "path": "corpus/wpf/timer-stop-early-return-guard/after.cs" + }, + { + "blob": "2e8e5e241d7980c65a70857fa128400c23331fed", + "path": "corpus/wpf/timer-stop-early-return-guard/before.cs" + }, + { + "blob": "743a4fab56737068377dbc553a030cc87273a465", + "path": "corpus/wpf/timer-stop-finalizer-release/after.cs" + }, + { + "blob": "973df1396ee32098c045e55dff973b979f13c1fc", + "path": "corpus/wpf/timer-stop-finalizer-release/before.cs" + }, + { + "blob": "d8e77d9849476e5491b4dcc19a9e53e48ff39795", + "path": "corpus/wpf/timer-stop-nonteardown-release/after.cs" + }, + { + "blob": "a2b1699fa2ce74a8bfab34c8d63a2374a9696723", + "path": "corpus/wpf/timer-stop-nonteardown-release/before.cs" + }, + { + "blob": "d59b693ecf990fd43d60a1051544f40e1ad2c818", + "path": "corpus/wpf/timer-stop-param-guarded/after.cs" + }, + { + "blob": "012854a1e19f04133dc78ecbbd14a1cef8044622", + "path": "corpus/wpf/timer-stop-param-guarded/before.cs" + }, + { + "blob": "e76351d486fd80e1037a4bca2ab9783c7ae4c1fd", + "path": "corpus/wpf/timer-stop-uncalled-helper/after.cs" + }, + { + "blob": "42a743ff9743fd38551eaf687b0a96ac874f0eb8", + "path": "corpus/wpf/timer-stop-uncalled-helper/before.cs" + }, + { + "blob": "0a65c2215f03fc979d71d4f91458043e2b02a143", + "path": "corpus/wpf/timer-stop-uncalled-lambda/after.cs" + }, + { + "blob": "3c29d5f0fe3f49b79244fd482e18bc9a39b1bb52", + "path": "corpus/wpf/timer-stop-uncalled-lambda/before.cs" + }, + { + "blob": "39bef7650422dfbac6319adbf0a82a99105a9ee6", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/after.cs" + }, + { + "blob": "0d5062f2477f382150b32b286aa8726e51170200", + "path": "corpus/wpf/timer-stop-unwired-lifecycle/before.cs" + }, + { + "blob": "b2b6b657b0da7947086911cd2833278e1ca926c2", + "path": "corpus/wpf/timer-stop-wrong-receiver/after.cs" + }, + { + "blob": "d781717509873e414e92801419decddb32e0f826", + "path": "corpus/wpf/timer-stop-wrong-receiver/before.cs" + }, + { + "blob": "82f57d8b91534fd08c54f1b1f0857c3f8c76d46e", + "path": "corpus/wpf/viewmodel-escapes-to-app/after.cs" + }, + { + "blob": "ae52b324a6e428015fc5974bd11d60f8bfe3e4d0", + "path": "corpus/wpf/viewmodel-escapes-to-app/before.cs" + }, + { + "blob": "1f96bb7c57b978ff329761ca730a7d975b39fba9", + "path": "corpus/wpf/zombie-viewmodel/after.cs" + }, + { + "blob": "e9e4d0700a5abff8114dbe619993069b05bd6fc2", + "path": "corpus/wpf/zombie-viewmodel/before.cs" + } + ], + "analysis_manifest_sha256": "97ea59f4b4e7409597cdc00bf0e7d6496397b5c24f8c7785a063c507a23d5397", + "artifacts": { + "own-cli": { + "binary": "own-cli", + "bytes": 1842008, + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "cargo_argv": [ + "cargo", + "build", + "--locked", + "--release", + "--message-format=json", + "-p", + "own-cli", + "--bin", + "own-cli" + ], + "cargo_clean_argv": [ + "cargo", + "clean", + "--release", + "-p", + "own-cli" + ], + "cargo_lock_blob": "d8adbb1dc4d90da0c80aa1a2d8ba85bef805620f", + "cargo_lock_sha256": "17553420691d96febcfac54bd8f530b4f9e2a1ad7c79e6aaa022510e56692f45", + "dirty": false, + "executable": "/home/tandem/cargo-target/release/own-cli", + "executed": { + "bytes": 1842008, + "post_run_intact": true, + "sealed_path": "/home/tandem/owen-p037-a2/tmp/p037-take-ekpp6rdt/own-cli", + "sha256": "8373f5f58a8dda4c2fe552185364c4c0c1834149d7b8865fa643a88b7d7cc4b8" + }, + "host": "x86_64-unknown-linux-gnu", + "package": "own-cli", + "profile": "release", + "rebuilt_by_this_call": true, + "repo_path": null, + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8", + "sha256": "8373f5f58a8dda4c2fe552185364c4c0c1834149d7b8865fa643a88b7d7cc4b8", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2" + } + }, + "corpus": [ + "corpus/real-world", + "corpus/wpf", + "corpus/di", + "corpus/fixtures", + "corpus/p036-bakeoff" + ], + "dirty": false, + "engine": "rust", + "execution_profile": { + "dotnet": { + "runtimes": [ + "Microsoft.AspNetCore.App 8.0.31", + "Microsoft.NETCore.App 8.0.31" + ], + "sdk": "8.0.425" + }, + "platform": { + "machine": "x86_64", + "system": "Linux" + }, + "python": { + "implementation": "CPython", + "version": "3.11.15 (main, Sep 19 2026, 00:18:08) [GCC 16.1.1 20260625]" + }, + "rust": { + "cargo": "cargo 1.94.1 (29ea6fb6a 2026-03-24)", + "host": "x86_64-unknown-linux-gnu", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8" + } + }, + "files": { + "corpus/di/singleton-captures-scoped-dbcontext/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/di/singleton-captures-scoped-dbcontext/before.cs": { + "exit": 0, + "findings": [ + { + "code": "DI001", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/fixtures/systemevents-console/Program.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 43 + }, + { + "code": "OWN001", + "level": "warning", + "line": 54 + }, + { + "code": "OWN001", + "level": "warning", + "line": 77 + } + ] + }, + "corpus/p036-bakeoff/guarded-consume-early-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-early-return/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-flag-branch/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-negation-wrapper/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/guarded-consume-wrapper-forward/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/p036-bakeoff/gv4-control-aliased-self-null/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 28 + } + ] + }, + "corpus/p036-bakeoff/gv4-control-mutated-guard/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 38 + } + ] + }, + "corpus/p036-bakeoff/gv4-control-ref-alias-guard/control.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 35 + } + ] + }, + "corpus/p036-bakeoff/legacy-honesty-else-unresolved-forward/control.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ado-executereader-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ado-executereader-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 11 + } + ] + }, + "corpus/real-world/arraypool-aliased-receiver/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-aliased-receiver/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/arraypool-double-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-double-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/real-world/arraypool-field-fullspan-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-field-fullspan-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 40 + }, + { + "code": "OWN025", + "level": "warning", + "line": 46 + } + ] + }, + "corpus/real-world/arraypool-fullspan-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-fullspan-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 24 + }, + { + "code": "OWN025", + "level": "warning", + "line": 26 + } + ] + }, + "corpus/real-world/arraypool-length-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-length-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/real-world/arraypool-memory-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-memory-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/arraypool-span-view-after-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-span-view-after-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/arraypool-use-after-return/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-use-after-return/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/real-world/arraypool-view-into-field-overread/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/arraypool-view-into-field-overread/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN025", + "level": "warning", + "line": 40 + }, + { + "code": "OWN025", + "level": "warning", + "line": 41 + } + ] + }, + "corpus/real-world/field-dispose-via-exchange/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-dispose-via-exchange/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/real-world/field-dispose-via-helper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-dispose-via-helper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/field-noop-dispose-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/field-noop-dispose-wrapper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 9 + } + ] + }, + "corpus/real-world/local-dispose-via-using-statement/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/local-dispose-via-using-statement/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/real-world/memorypool-double-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-double-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN003", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-owner-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-owner-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-statement-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-statement-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/memorypool-using-view-escape/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-using-view-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/real-world/memorypool-view-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/memorypool-view-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/nethermind-patriciatree-arraypool-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/real-world/ownership-handoff-consume/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-consume/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN002", + "level": "warning", + "line": 28 + } + ] + }, + "corpus/real-world/ownership-handoff-use-transitive/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-use-transitive/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/real-world/ownership-handoff-use/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/ownership-handoff-use/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 22 + } + ] + }, + "corpus/real-world/pool-transfer-via-wrapper-local/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/pool-transfer-via-wrapper-local/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/real-world/screentogif-loaded-subscription/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 21 + } + ] + }, + "corpus/real-world/screentogif-loaded-subscription/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 24 + }, + { + "code": "OWN001", + "level": "warning", + "line": 25 + }, + { + "code": "OWN001", + "level": "warning", + "line": 26 + } + ] + }, + "corpus/real-world/screentogif-systemevents-leak/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 12 + }, + { + "code": "OWN050", + "level": "note", + "line": 13 + } + ] + }, + "corpus/real-world/screentogif-systemevents-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + } + ] + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/sharex-rfc2898-derivebytes-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 24 + }, + { + "code": "OWN001", + "level": "warning", + "line": 27 + } + ] + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/sharex-shapemanager-menuform-leak/before.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/socket-accept-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/socket-accept-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 10 + } + ] + }, + "corpus/real-world/subscription-self-owned-property/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/subscription-self-owned-property/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/real-world/tcplistener-accept-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/tcplistener-accept-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 11 + } + ] + }, + "corpus/real-world/tcplistener-acceptsocket-leak/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/tcplistener-acceptsocket-leak/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 10 + } + ] + }, + "corpus/real-world/using-statement-throw-releases/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/real-world/using-statement-throw-releases/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/wpf/custom-weak-wrapper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/custom-weak-wrapper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 13 + } + ] + }, + "corpus/wpf/field-use-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/field-use-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/handler-use-after-dispose-wrapped-delegate/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 15 + } + ] + }, + "corpus/wpf/handler-use-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/handler-use-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/pooled-view-after-dispose/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/pooled-view-after-dispose/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN002", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 20 + } + ] + }, + "corpus/wpf/subscription-ambiguous-overload-wiring/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 26 + }, + { + "code": "OWN050", + "level": "note", + "line": 27 + } + ] + }, + "corpus/wpf/subscription-disposing-else-branch-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-disposing-else-branch-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 25 + } + ] + }, + "corpus/wpf/subscription-explicit-delegate-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-explicit-delegate-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/wpf/subscription-finalizer-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-finalizer-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 22 + } + ] + }, + "corpus/wpf/subscription-nonteardown-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-nonteardown-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 21 + } + ] + }, + "corpus/wpf/subscription-overload-conflated-cleanup/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-overload-conflated-cleanup/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/wpf/subscription-param-guarded-unregister/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-param-guarded-unregister/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 25 + } + ] + }, + "corpus/wpf/subscription-target-typed-delegate-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-target-typed-delegate-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 14 + } + ] + }, + "corpus/wpf/subscription-teardown-early-return-guard/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-teardown-early-return-guard/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 31 + } + ] + }, + "corpus/wpf/subscription-uncalled-local-function/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-uncalled-local-function/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + }, + { + "code": "OWN001", + "level": "warning", + "line": 42 + } + ] + }, + "corpus/wpf/subscription-xaml-name-only-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/subscription-xaml-name-only-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 23 + } + ] + }, + "corpus/wpf/systemevents-region-escape/after.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 15 + }, + { + "code": "OWN050", + "level": "note", + "line": 16 + } + ] + }, + "corpus/wpf/systemevents-region-escape/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 26 + } + ] + }, + "corpus/wpf/timer-stop-disposing-else-branch/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-disposing-else-branch/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 20 + } + ] + }, + "corpus/wpf/timer-stop-early-return-guard/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-early-return-guard/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 19 + } + ] + }, + "corpus/wpf/timer-stop-finalizer-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-finalizer-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-nonteardown-release/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-nonteardown-release/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 18 + } + ] + }, + "corpus/wpf/timer-stop-param-guarded/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-param-guarded/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-uncalled-helper/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-uncalled-helper/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-uncalled-lambda/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-uncalled-lambda/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-unwired-lifecycle/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-unwired-lifecycle/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 17 + } + ] + }, + "corpus/wpf/timer-stop-wrong-receiver/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/timer-stop-wrong-receiver/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 16 + } + ] + }, + "corpus/wpf/viewmodel-escapes-to-app/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/viewmodel-escapes-to-app/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN050", + "level": "note", + "line": 14 + } + ] + }, + "corpus/wpf/zombie-viewmodel/after.cs": { + "exit": 0, + "findings": [] + }, + "corpus/wpf/zombie-viewmodel/before.cs": { + "exit": 0, + "findings": [ + { + "code": "OWN001", + "level": "warning", + "line": 13 + } + ] + } + }, + "input_roots": [ + "corpus/real-world", + "corpus/wpf", + "corpus/di", + "corpus/fixtures", + "corpus/p036-bakeoff" + ], + "instrument_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py" + ], + "is_evidence": true, + "materialization_root": ".p037-population/4a8e6582e10222403cd40adc9e95db7e0228a1c2/97ea59f4b4e74095", + "population_commit": "4a8e6582e10222403cd40adc9e95db7e0228a1c2", + "post_run_population_intact": true, + "reference_profile": { + "OWN_EXTRA_REF_DIRS": "removed-from-child-environment", + "observed_extra_reference_lines": 0 + }, + "schema": "p037-verdict-snapshot/3", + "source_commit": "5a0de070af241a2612859153887ad6ae04afcce2", + "subject_paths": [ + "ownlang/", + "rust/", + "scripts/own-check.sh", + "scripts/p037_evidence.py", + "scripts/p037_mos_snapshot.py", + "scripts/p037_verdict_snapshot.py", + "scripts/shadow_compare.py", + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ], + "support_manifest": [], + "support_manifest_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "treatment_paths": [ + "frontend/roslyn/OwnSharp.Extractor/", + "spec/" + ] +}