@descryy/adapter-csharp 0.1.0

package/dist/extract.d.ts

@@ -0,0 +1,83 @@
+/**
+ * C# files to Canonical IR.
+ *
+ * ## Identity is the project plus the declared namespace
+ *
+ * Not the namespace alone. C# namespaces do not follow directories and the same
+ * namespace legitimately spans projects, so two `.csproj` files in one
+ * repository may both declare `Shop.Orders.OrderService`. That is DEC-077's
+ * collision — the Java case where one fully-qualified name existed under two
+ * source sets and stopped identifying anything — and the project is C#'s
+ * equivalent separator.
+ *
+ * ## Two decisions land here, both taken before this file was written
+ *
+ * **DEC-083, a declaration that spans files.** `partial class` is the first
+ * construct in this project whose declaration is legitimately multi-file. The
+ * merge is free — a node id never contains a file path — so the parts collapse
+ * to one node with no new machinery. `file` is the lexicographically first
+ * declaring path and every part is listed in `attrs.declaredIn`, which is what
+ * a precision adjudicator has to search instead of `file`.
+ *
+ * **DEC-084, the base list.** `class A : B, IC` does not say which entry is the
+ * class, but the language does: at most one base class, and it must be first.
+ * So entries after the first are `IMPLEMENTS` unconditionally, a struct's and an
+ * interface's entries are all `IMPLEMENTS`, and exactly one entry per class ever
+ * needs resolving. The `IFoo` prefix is never read — it is a convention,
+ * `System.Exception` disproves it in the other direction, and inferring an edge
+ * from a naming habit is what golden pattern 12 exists to punish.
+ *
+ * ## Ambiguity is disclosed, never broken
+ *
+ * A `using` imports a whole namespace, so a bare name can be found under two of
+ * them at once. Real C# resolves that with the full type environment; this
+ * adapter has names only, so two candidates produce a ledger entry and no edge.
+ * Extension methods are the same answer for the same reason: `x.Foo()` where
+ * `Foo` is a static method on an unrelated class, selected by the receiver's
+ * type, is not decidable from names.
+ */
+import { type IdentityScope, type IREdge, type IRNode, type ResolutionLevel, type UnresolvedRef } from "@descryy/ir";
+import type { CsFile } from "./parse.ts";
+import { type NullableContext } from "./nullability.ts";
+export declare const LANGUAGE = "csharp";
+export interface ExtractInput {
+    readonly repo: string;
+    readonly scope: IdentityScope;
+    readonly producedBy: string;
+    readonly reached: ResolutionLevel;
+    readonly files: readonly CsFile[];
+    /**
+     * Repo-relative path -> source text, for the framework extractors.
+     *
+     * The Fluent API and minimal-API registrations are call chains rather than
+     * declarations, and reading them faithfully from the tree would mean modelling
+     * the whole builder. `efcore.ts` and `aspnetcore.ts` read them textually and
+     * refuse everything they cannot evaluate, which is a smaller claim honestly
+     * made — see their file comments. They need the text to do it.
+     *
+     * Empty when the caller has none: both extractors then see no files, emit
+     * nothing, and the language half is unaffected.
+     */
+    readonly sources?: ReadonlyMap<string, string>;
+    /**
+     * The NRT context governing a file, resolved by the caller.
+     *
+     * Supplied by the adapter, which is the only layer holding the `.csproj` and
+     * the `Directory.Build.props` — DEC-180 §1's second and third sources. Without
+     * it this falls back to `#nullable` directives alone, which answers `absent`
+     * for a repository whose declaration is in its project files, and every
+     * reference-typed column comes out `unresolved`.
+     *
+     * That fallback is honest degradation rather than a guess, and it is the wrong
+     * answer for a fixture: the conformance corpus declares `<Nullable>enable</Nullable>`
+     * in `Shop.csproj` and golden 06's `discount_code` is a nullable `string?`.
+     */
+    readonly nullableContextOf?: (file: string) => NullableContext;
+}
+export interface Extraction {
+    readonly nodes: readonly IRNode[];
+    readonly edges: readonly IREdge[];
+    readonly unresolved: readonly UnresolvedRef[];
+}
+export declare function extract(input: ExtractInput): Extraction;
+//# sourceMappingURL=extract.d.ts.map

package/dist/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,MAAM,EAAwD,MAAM,YAAY,CAAC;AAG/F,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAI7F,eAAO,MAAM,QAAQ,WAAW,CAAC;AAgDjC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;CAChE;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/C;AAgCD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAwlCvD"}