From 3a6e4f2cb148b123ebba7c05f5aa5b75bfe71b30 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Tue, 27 Oct 2026 05:42:46 +0800 Subject: [PATCH] fix(managed): report graph method page coverage --- src/domain/managed/managedApplicationGraph.ts | 9 +++ .../managedApplicationGraphCoverage.ts | 12 +++- .../managedApplicationGraph.test.ts | 58 ++++++++++++++++++- 3 files changed, 76 insertions(+), 3 deletions(-) diff --git a/src/domain/managed/managedApplicationGraph.ts b/src/domain/managed/managedApplicationGraph.ts index 29b5c710a4..f0def87f6e 100644 --- a/src/domain/managed/managedApplicationGraph.ts +++ b/src/domain/managed/managedApplicationGraph.ts @@ -395,6 +395,15 @@ const projectionLimitations = ( : [ `Managed member Evidence selected only these declaring types: ${omissions.selectedTypes.join(", ")}; type, method, and field nodes of other types are omitted, not absent.`, ]), + ...(omissions.methodRows === undefined + ? [] + : omissions.methodRows === null + ? [ + "Managed member Evidence did not record its MethodDef row scope; coverage of methods and their relations outside the supplied observations is unknown.", + ] + : [ + `Managed member Evidence examined MethodDef rows at offset ${omissions.methodRows.offset} with count ${omissions.methodRows.count} of ${omissions.methodRows.total} total rows; methods outside that interval and their relations are omitted, not absent.`, + ]), ...(omissions.unscopedTokenRelationships ? [ "Managed boundary tokens were not linked to member nodes because matching module MVID scope was not established.", diff --git a/src/domain/managed/managedApplicationGraphCoverage.ts b/src/domain/managed/managedApplicationGraphCoverage.ts index e8cc9f927e..d7754f14c8 100644 --- a/src/domain/managed/managedApplicationGraphCoverage.ts +++ b/src/domain/managed/managedApplicationGraphCoverage.ts @@ -50,6 +50,8 @@ export interface ManagedGraphProjectionOmissions { readonly unscopedTokenRelationships: boolean; /** Declaring types the member Evidence selected; null when it inspected every type. */ readonly selectedTypes: readonly string[] | null; + /** Undefined when all MethodDef rows were examined or member Evidence is absent. */ + readonly methodRows: ManagedMemberInspection["method_rows"] | undefined; /** Counted call and field-access sites without edges; null without member Evidence. */ readonly relations: ManagedRelationOmissions | null; } @@ -58,7 +60,8 @@ export interface ManagedGraphProjectionOmissions { const omitsUncounted = (omissions: ManagedGraphProjectionOmissions): boolean => omissions.partialInput || omissions.unscopedTokenRelationships || - omissions.selectedTypes !== null; + omissions.selectedTypes !== null || + omissions.methodRows !== undefined; const omitsAny = (omissions: ManagedGraphProjectionOmissions): boolean => omitsUncounted(omissions) || omittedRelationSites(omissions.relations) > 0; @@ -106,6 +109,13 @@ export const assessManagedGraphOmissions = ( sources.artifact?.coverage.state, ].some((state) => state !== undefined && state !== "complete"), selectedTypes: sources.members?.selection?.type_names ?? null, + methodRows: + sources.members === null || + (sources.members.method_rows !== null && + sources.members.method_rows.offset === 0 && + sources.members.method_rows.count === sources.members.method_rows.total) + ? undefined + : sources.members.method_rows, }); /** Derive graph coverage solely from the coverage of supplied source evidence. */ diff --git a/tests/composition/analysis-sessions/managedApplicationGraph.test.ts b/tests/composition/analysis-sessions/managedApplicationGraph.test.ts index 266896f8ae..e24b488566 100644 --- a/tests/composition/analysis-sessions/managedApplicationGraph.test.ts +++ b/tests/composition/analysis-sessions/managedApplicationGraph.test.ts @@ -24,9 +24,12 @@ import { const tinyIl = (il: readonly number[]): Buffer => Buffer.from([(il.length << 2) | 2, ...il]); -const memberGraph = (bytes: Buffer) => { +const memberGraph = ( + bytes: Buffer, + options: Parameters[2] = {}, +) => { const binary = managedPeFixtureTarget(bytes, "/fixture/ManagedCalls.exe"); - const members = inspectManagedMembersBytes(bytes, binary); + const members = inspectManagedMembersBytes(bytes, binary, options); const memberEvidence = createEvidence(binary, MANAGED_STATIC_PROVIDER, { operation: "inspect_managed_members", parameters: {}, @@ -86,6 +89,57 @@ const createManagedInteropEvidence = () => { }; }; +describe("managed application graph MethodDef scope", () => { + it("preserves MethodDef page omissions from decoded member Evidence", () => { + const bytes = buildManagedPeFixture({ + ilBody: tinyIl([0x2a]), + methodRowCount: 3, + }); + const full = memberGraph(bytes); + expect(full.members.method_rows).toEqual({ offset: 0, count: 3, total: 3 }); + expect(full.result.coverage.status).toBe("complete-within-inputs"); + for (const options of [ + { methodLimit: 0 }, + { methodOffset: 1, methodLimit: 1 }, + { methodOffset: 3 }, + ]) { + const page = memberGraph(bytes, options); + expect(page.members.coverage.state).toBe("complete"); + expect(page.result.summary.methods).toBe(page.members.method_rows!.count); + expect(page.result.coverage.status).toBe("partial"); + expect(page.result.limitations).toContain( + `Managed member Evidence examined MethodDef rows at offset ${page.members.method_rows!.offset} with count ${page.members.method_rows!.count} of 3 total rows; methods outside that interval and their relations are omitted, not absent.`, + ); + } + }); + + it("keeps unrecorded legacy MethodDef scope unknown", () => { + const bytes = buildManagedPeFixture({ ilBody: tinyIl([0x2a]) }); + const binary = managedPeFixtureTarget(bytes); + const members = inspectManagedMembersBytes(bytes, binary); + const { method_rows: _methodRows, ...legacy } = members; + const evidence = createEvidence(binary, MANAGED_STATIC_PROVIDER, { + operation: "inspect_managed_members", + parameters: {}, + result: legacy, + rawResult: null, + limitations: members.limitations, + }); + const projection = projectManagedApplicationGraphEvidence({ + managed_members: evidence, + }); + if (!projection.ok) throw new Error(JSON.stringify(projection.error)); + const result = managedApplicationGraphResultSchema.parse( + parseEvidence(projection.value).normalized_result, + ); + expect(result.coverage.status).toBe("partial"); + expect(result.summary.methods).toBe(1); + expect(result.limitations).toContain( + "Managed member Evidence did not record its MethodDef row scope; coverage of methods and their relations outside the supplied observations is unknown.", + ); + }); +}); + describe("managed application graph projection", () => { it("projects managed metadata and native declarations into authenticated graph Evidence", () => { const { artifactEvidence, memberEvidence, boundaryEvidence } =