@lzehrung/codegraph 2.3.30 → 2.4.0

package/dist/indexer/compilation-units.d.ts

@@ -0,0 +1,101 @@
+import type { FileId, Range } from "../types.js";
+import type { ProjectIndex } from "./types.js";
+/**
+ * Proven same-compilation-unit peers for implicit bare-name visibility and shared-owner lookup
+ * (C# partial classes, Swift extensions).
+ *
+ * The unit relation is deliberately narrow and matches the facts current resolution already
+ * proves (`resolveGoPackageExport` / `resolveSiblingPackageExport`): the file's directory plus
+ * its language unit identity - the `package` clause for Go and the JVM languages, declared C#
+ * namespaces (including the global namespace), and the containing directory for Swift, whose
+ * module identity is not declared in source. Lookup never falls back to a project-wide
+ * same-name scan, so unrelated same-named declarations in other directories, packages,
+ * namespaces, or modules are never bare-name peers. C# `Namespace.Type` and
+ * `global::Namespace.Type` names may additionally search other same-directory C# files
+ * whose namespaces are not related for bare-name lookup; that qualified set still stops
+ * at the unit directory.
+ *
+ * Documented limits:
+ * - No compiler/build-target inference: Maven/Gradle source roots, csproj items, and SwiftPM
+ *   targets are not read. A package that legitimately spans directories (for example
+ *   `src/main/java` and `src/test/java`) is one language-level unit that this directory-scoped
+ *   relation only partially enumerates; `complete` reports `false` in that situation because
+ *   same-identity files exist outside the unit directory.
+ * - Go is directory-exact by language definition, so `complete` depends only on reading the
+ *   package clause; the same package spelling in another directory is a different package.
+ * - Java/Kotlin files without a `package` clause (the unnamed package) have no identity that
+ *   groups files, so they return only themselves. `complete` is false when another indexed file
+ *   has no package clause or an unreadable package, because that file might belong to the same
+ *   unnamed package. When the index has no such file, this file is the whole unit and
+ *   `complete` is true.
+ * - Kotlin `internal` and C# `internal` declarations are hidden from module exports, so this
+ *   lookup cannot see them across files; such references stay unresolved rather than being
+ *   matched speculatively. Java package-private and Swift `internal` declarations are export
+ *   entries and are matched normally.
+ * - C# namespace visibility uses the declaration and use-site positions. A file-level lookup
+ *   without a use position accepts a namespaced declaration only when every declared namespace
+ *   can see it; it must not select a declaration visible in just one region.
+ *
+ * All facts are cached per `ProjectIndex` in memory only (like the existing package-directory
+ * lookups) and are never persisted: they derive from indexed file paths and indexed file
+ * sources, which the index already fingerprints per file. No build manifests or other
+ * untracked inputs are read.
+ */
+export type CompilationUnitPeers = {
+    files: ReadonlySet<FileId>;
+    complete: boolean;
+};
+/** Languages whose files can name each other's top-level declarations without an import. */
+export declare const IMPLICIT_UNIT_LANGUAGES: Readonly<Record<string, true>>;
+/**
+ * A C# namespace declaration and the source span it governs. A block-scoped namespace spans
+ * from its `namespace` keyword to the matching `}`; a file-scoped one spans to end of file.
+ * Nested block scopes compose their names (`Outer` and `Outer.Inner`), so the innermost region
+ * containing a declaration is its namespace.
+ */
+export type CsharpNamespaceRegion = {
+    name: string;
+    start: number;
+    end: number;
+};
+/** The declared package name, or null when absent or unreadable. */
+export declare function getPackageDeclarationName(index: ProjectIndex, filePath: string, languageId: "go" | "java" | "kotlin"): string | null;
+/**
+ * The C# namespace regions of a file, or `null` when its source cannot be read. Cached per
+ * index alongside the package-clause facts.
+ */
+export declare function getCsharpNamespaceRegions(index: ProjectIndex, filePath: string): readonly CsharpNamespaceRegion[] | null;
+/** The normalized C# namespace enclosing `position` in a file (`""` for global), or `null` when unreadable. */
+export declare function csharpNamespaceAt(index: ProjectIndex, filePath: string, position: number): string | null;
+/**
+ * True when a top-level declaration at `declaration` in `declarationFile` can be named without
+ * an import from within `useFile`. Both files must already share a compilation unit (see
+ * `getCompilationUnitPeers`); this refines the file-level relation at declaration granularity,
+ * which only matters for C# files that declare several namespaces. For every other unit
+ * language the file-level identity is the full visibility rule.
+ */
+export declare function isUnitBareNameVisible(args: {
+    index: ProjectIndex;
+    declarationFile: FileId;
+    declaration: Range;
+    useFile: FileId;
+    useIndex?: number;
+    qualification?: string;
+}): boolean;
+/**
+ * Every indexed file that shares a proven compilation unit with `file`, including `file`
+ * itself. `complete` is `false` when the unit boundary cannot be proven: the identity is
+ * unreadable, the language's unit is not file/directory derivable, or same-identity files
+ * exist outside the unit directory so the unit may extend beyond it. Consumers must retain
+ * the proven peer set and report partial coverage instead of implying that every possible
+ * peer was considered.
+ *
+ * Pass `csharpQualifiedName` for C# `Namespace.Type` / `global::Namespace.Type` lookup so
+ * same-directory files whose namespaces are not related for bare names are still searched.
+ * Qualified names can also cross otherwise unrelated namespaces outside the directory,
+ * so those files leave the qualified candidate set incomplete. Other languages ignore the flag.
+ */
+export declare function getCompilationUnitPeers(index: ProjectIndex, file: FileId, options?: {
+    csharpQualifiedName?: boolean;
+}): CompilationUnitPeers;
+//# sourceMappingURL=compilation-units.d.ts.map

package/dist/indexer/compilation-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilation-units.d.ts","sourceRoot":"","sources":["../../src/indexer/compilation-units.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAUjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAMlE,CAAC;AAqCF;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA+IF,oEAAoE;AACpE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,IAAI,GAAG,MAAM,GAAG,QAAQ,GACnC,MAAM,GAAG,IAAI,CAEf;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,GACf,SAAS,qBAAqB,EAAE,GAAG,IAAI,CAazC;AA+ED,+GAA+G;AAC/G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxG;AAyBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,YAAY,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,KAAK,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CA0BV;AAsQD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GAC1C,oBAAoB,CAUtB"}