@cdxgen/cdxgen 13.2.0 → 13.4.0

package/types/lib/evinser/evinser.d.ts

@@ -1,3 +1,46 @@
+/**
+ * Merges one analyzer run's metadata properties into the BOM's metadata
+ * component. Analyzer metadata describes a single run, so when the input BOM
+ * already carries facts from an earlier run (cdxgen --profile research, then
+ * evinse), everything under the analyzer's own `cdx:<analyzer>:` prefix is
+ * replaced. Replacing by exact name would keep facts the new run no longer
+ * emits, such as a cdx:rusi:requestedBackend left from a fallback run.
+ *
+ * @param {Object} component Metadata component to update in place
+ * @param {Object[]} metadataProperties Properties from the analyzer run
+ */
+export declare function mergeAnalyzerMetadataProperties(component: Object, metadataProperties?: Object[]): void;
+/**
+ * The evidence language of a `cdxgen --evidence` run that names no project
+ * type.
+ *
+ * A directory with a Scala build takes the scalasem path. Otherwise the
+ * generated BOM decides: Java when it lists Maven packages, as before, and
+ * else the language most of its packages belong to. A BOM with no package in
+ * a language the evidence step analyses gives no language, so no analyzer
+ * runs over sources it cannot read.
+ *
+ * @param {string} dirPath Project directory
+ * @param {Object} [bomJson] The BOM generated for the directory
+ * @param {Object} [options] CLI options, for the exclude patterns
+ * @returns {string|undefined} Project type for the evidence phase
+ */
+export declare function defaultEvidenceLanguage(dirPath: string, bomJson?: Object, options?: Object): string | undefined;
+/**
+ * Build the options for the evinse phase (prepareDB, analyzeProject, and
+ * createEvinseFile) from the cdxgen CLI options.
+ *
+ * This object used to be assembled inline in bin/cdxgen.js, which dropped
+ * fields the analyzers read - most notably `exclude`, so every dosai and atom
+ * run triggered by `--evidence` ignored the user's `--exclude` patterns. Keep
+ * the wiring in one place so the forwarded fields stay testable.
+ *
+ * @param {Object} options CLI options
+ * @param {Object} args Parsed CLI arguments; `args._[0]` is the source directory
+ * @param {string} input Path of the BOM file the evinse phase enriches
+ * @returns {Object} Options for prepareDB, analyzeProject, and createEvinseFile
+ */
+export declare function buildEvinseOptions(options: Object, args: Object, input: string): Object;
 /**
  * Function to create the db for the libraries referred in the sbom.
  *
@@ -11,11 +54,22 @@ export declare function prepareDB(options: Object): Promise<{
     Usages: Object;
     DataFlows: Object;
 } | undefined>;
+/**
+ * Read the jar namespace map cdxgen writes next to the BOM it generates
+ * (`<bom>.map`). The map for the BOM passed as `--input` is preferred; a
+ * `bom.json.map` in the project directory is the fallback.
+ *
+ * @param {string} dirPath Project directory scanned by evinse
+ * @param {Object} [options] CLI options, for `input`
+ * @returns {Object|undefined} The mapping, when a non-empty one exists.
+ */
+export declare function readNamespaceMap(dirPath: string, options?: Object): Object | undefined;
 /**
  * Collect Maven jar namespace mappings for the purls found in the SBOM.
  *
- * If a previously generated `bom.json.map` is present in `dirPath` it is reused;
- * otherwise the maven command is invoked to collect the jar dependencies. Each
+ * If cdxgen left a namespace map next to the BOM (see {@link readNamespaceMap})
+ * it is reused; otherwise the maven command is invoked to collect the jar
+ * dependencies. Each
  * resolved purl is recorded in the `purlsJars` map and persisted in the
  * `Namespaces` model.
  *
@@ -37,7 +91,7 @@ export declare function catalogMavenDeps(dirPath: string, purlsJars: Record<stri
  * @param {Object} Namespaces Sequelize-like Namespaces model used to persist pom and namespaces
  * @returns {Promise<void>}
  */
-export declare function catalogGradleDeps(dirPath: string, purlsJars: Record<string, string>, Namespaces: Object): Promise<void>;
+export declare function catalogGradleDeps(dirPath: string, purlsJars: Record<string, string>, Namespaces: Object, options?: {}): Promise<void>;
 /**
  * Generate a usage slice for the given purl and persist it in the Usages model.
  *
@@ -91,8 +145,9 @@ export declare function purlToLanguage(purl: string, filePath?: string): string
  * Seed purl-location and import maps from SBOM component evidence.
  *
  * Walks the supplied components reading `internal:ImportedModules` (or
- * `internal:Namespaces` for php/ruby) and `evidence.occurrences` properties
- * to construct lookup maps used during slice analysis.
+ * `internal:Namespaces` for php/ruby, plus the `internal:ImportedSymbols` the
+ * C/C++ collector records) and `evidence.occurrences` properties to construct
+ * lookup maps used during slice analysis.
  *
  * @param {Object[]} components CycloneDX components from the input SBOM
  * @param {string} language Application language used to select the import property name
@@ -102,13 +157,43 @@ export declare function initFromSbom(components: Object[], language: string): {
     purlLocationMap: Record<string, Set<any>>;
     purlImportsMap: Record<string, string[]>;
 };
+/**
+ * Load a semantics slices file for reuse when it belongs to this project.
+ *
+ * `--semantics-slices-file` defaults to `semantics.slices.json` in the working
+ * directory, which is shared by every project scanned from there and also
+ * receives the reports of other analyzers (dosai, rusi, golem). A file is
+ * only reused when its shape matches the language. Swift slices must also
+ * describe the same project directory and must not predate the input SBOM:
+ * `cdxgen --evidence` writes a fresh SBOM before evinse runs, so an older
+ * slice was made from an earlier state of the sources and is regenerated.
+ * Scala reports are handled by the scalasem analyzer, which applies its own
+ * rules.
+ *
+ * @param {string} language Project language
+ * @param {string} slicesFile Candidate semantics slices file
+ * @param {string} bomFile Input SBOM
+ * @param {string} dirPath Project directory
+ * @returns {undefined|Object} Parsed slice when it can be reused
+ */
+export declare function loadReusableSemanticsSlice(language: string, slicesFile: string, bomFile: string, dirPath: string): undefined | Object;
+/**
+ * Merge service definitions into a services map: endpoints join, and a
+ * property another source already carries is not added again, whatever the
+ * case of an HTTP method.
+ *
+ * @param {Object} target Services map that receives the definitions.
+ * @param {Object} source Services map to merge in.
+ * @returns {Object} The target map.
+ */
+export declare function mergeServiceDefinitions(target: Object, source: Object): Object;
 /**
  * Function to analyze the project
  *
  * @param {Object} dbObjMap DB and model instances
  * @param {Object} options Command line options
  */
-export declare function analyzeProject(dbObjMap: Object, options: Object): Promise<{
+export declare function analyzeProject(dbObjMap: Object, options: Object): Promise<Object | {
     purlLocationMap: Record<string, Set<any>>;
     servicesMap: {};
     dataFlowFrames: {};
@@ -155,13 +240,7 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
     cryptoGeneratePurls: {};
     servicesMap: {};
     userDefinedTypesMap: {};
-    workspaceComponent: {
-        type: string;
-        name: any;
-        version: any;
-        purl: any;
-        "bom-ref": any;
-    } | undefined;
+    workspaceComponent: Object | undefined;
     atomFile?: undefined;
     usagesSlicesFile?: undefined;
     dataFlowSlicesFile?: undefined;
@@ -227,7 +306,37 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
  * @param {string} [openapiSpecFile=undefined] Optional path to an OpenAPI spec used for service detection
  * @returns {Promise<Object>} Map with `purlLocationMap`, `servicesMap`, and `userDefinedTypesMap`
  */
-export declare function parseObjectSlices(language: string, usageSlice: Object, dbObjMap: Object, servicesMap?: Object, purlLocationMap?: Record<string, Set<any>>, purlImportsMap?: Record<string, string[]>, openapiSpecFile?: string): Promise<Object>;
+/**
+ * Attribute the include slices of a C/C++ usages report to the BOM
+ * components that provide the files they resolved to: each header's imported
+ * symbols (the functions the including file calls that it declares), and the
+ * include directive's location. Reports from atom releases that do not name
+ * the resolved file attribute nothing.
+ *
+ * @param {Object} usageSlice Parsed usages report
+ * @param {Object[]} components Components of the input BOM
+ * @param {string} dirPath Source directory
+ * @param {Object} options CLI options
+ * @returns {{symbols: Map<string, Set<string>>, locations: Map<string, Set<string>>}}
+ *   Imported symbols and include locations (`file#line`) by purl
+ */
+export declare function attributeCIncludes(usageSlice: Object, components: Object[], dirPath: string, options?: Object): {
+    symbols: Map<string, Set<string>>;
+    locations: Map<string, Set<string>>;
+};
+/**
+ * Seed the C/C++ imports from the include slices of a usages report (see
+ * `attributeCIncludes`).
+ *
+ * @param {Object} usageSlice Parsed usages report
+ * @param {Object[]} components Components of the input BOM
+ * @param {string} dirPath Source directory
+ * @param {Object} purlImportsMap Imports by purl, extended in place
+ * @param {Object} options CLI options
+ * @returns {Object} purlImportsMap
+ */
+export declare function seedCImportsFromIncludes(usageSlice: Object, components: Object[], dirPath: string, purlImportsMap?: Object, options?: Object): Object;
+export declare function parseObjectSlices(language: any, usageSlice: any, dbObjMap: any, servicesMap?: {}, purlLocationMap?: {}, purlImportsMap?: {}, openapiSpecFile?: undefined): Promise<{}>;
 /**
  * The implementation of this function is based on the logic proposed in the atom slices specification
  * https://github.com/AppThreat/atom/blob/main/specification/docs/slices.md#use
@@ -244,12 +353,20 @@ export declare function parseSliceUsages(language: string, userDefinedTypesMap:
 /**
  * Method to parse semantic slice data. Currently supported for swift and scala languages.
  *
+ * Swift slices created by cdxgen record, for every indexed source file, the
+ * lines that reference each dependency module (`moduleReferences`); the module
+ * of a reference is the declaring module recovered from the compiler-resolved
+ * USR. Components are mapped to their package's modules through the
+ * `packages` slice, so every occurrence is backed by a resolved reference.
+ * Slices without `moduleReferences` (created by older cdxgen versions) fall
+ * back to matching symbol names.
+ *
  * @param {String} language Project language.
  * @param {Array} components Components from the input SBOM
  * @param {Object} semanticsSlice Semantic slice data
  * @returns {Object} Parsed metadata
  */
-export declare function parseSemanticSlices(language: string, components: any[], semanticsSlice: Object): Object;
+export declare function parseSemanticSlices(_language: any, components: any[], semanticsSlice: Object): Object;
 /**
  * Decide whether a type name should be ignored during slice analysis.
  *

package/types/lib/evinser/evinser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evinser.d.ts","sourceRoot":"","sources":["../../../lib/evinser/evinser.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"evinser.d.ts","sourceRoot":"","sources":["../../../lib/evinser/evinser.js"],"names":[],"mappings":"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"}

package/types/lib/evinser/swiftsem.d.ts

@@ -1,11 +1,66 @@
+/**
+ * Convert a SwiftPM target or package name into its module name.
+ *
+ * @param {String} name Target or package name
+ * @returns {String} Module name
+ */
+export declare function toModuleName(name: string): string;
+/**
+ * Decide whether a module belongs to tests or to an aggregate product and so
+ * must not contribute build symbols or semantic context.
+ *
+ * @param {String} moduleName Module name
+ * @returns {boolean} `true` when the module should be skipped
+ */
+export declare function isTestOrAggregateModule(moduleName: string): boolean;
+/**
+ * Parse the JSON printed by `swift -print-target-info`.
+ *
+ * `paths.runtimeResourcePath` is `<toolchain>/usr/lib/swift` for every
+ * toolchain layout (Xcode, `.xctoolchain` bundles, swiftly, Linux tarballs),
+ * so it names the toolchain that actually compiles the project.
+ *
+ * @param {Object} targetInfo Parsed `-print-target-info` output
+ * @returns {undefined|Object} `{ compilerVersion, triple, runtimeResourcePath, toolchainDir }`
+ */
+export declare function parseSwiftTargetInfo(targetInfo: Object): undefined | Object;
+/**
+ * Identify the toolchain that `swift` resolves to inside a project directory.
+ *
+ * The query runs in the project directory because toolchain managers such as
+ * swiftly select the toolchain per directory (`.swift-version`), so the
+ * compiler that builds a project can differ from the one on the PATH of the
+ * calling process.
+ *
+ * @param {String} basePath Project directory
+ * @returns {undefined|Object} Toolchain details, see parseSwiftTargetInfo
+ */
+export declare function resolveSwiftToolchain(basePath: string): undefined | Object;
+/**
+ * Environment overrides that make sourcekitten load the SourceKit of the
+ * toolchain that builds the project.
+ *
+ * Without guidance sourcekitten uses the toolchain of the selected Xcode (or
+ * the `swift` found on the PATH on Linux). SourceKit cannot load modules
+ * produced by a different compiler version, so every reference to a
+ * dependency then goes unresolved. On macOS sourcekitten honours
+ * `XCODE_DEFAULT_TOOLCHAIN_OVERRIDE` ahead of `xcrun`; on Linux it honours
+ * `LINUX_SOURCEKIT_LIB_PATH`. Explicitly configured values always win.
+ *
+ * @param {Object} toolchain Toolchain details from resolveSwiftToolchain
+ * @param {String} [platform] Platform name, defaults to process.platform
+ * @returns {undefined|Object} Environment overrides for sourcekitten
+ */
+export declare function sourcekittenEnvForToolchain(toolchain: Object, platform?: string): undefined | Object;
 /**
  * Retrieve the structure information of a .swift file in json format
  *
  * @param {String} filePath Path to .swift file
+ * @param {Object} [env] Environment overrides for sourcekitten
  *
  * @returns {undefined|Object} JSON representation of the swift file or undefined.
  */
-export declare function getStructure(filePath: string): undefined | Object;
+export declare function getStructure(filePath: string, env?: Object): undefined | Object;
 /**
  * Parse the data from the structure command
  *
@@ -13,35 +68,150 @@ export declare function getStructure(filePath: string): undefined | Object;
  * @returns {Object|undefined} Parsed value
  */
 export declare function parseStructure(structureJson: Object): Object | undefined;
+/**
+ * Split a Swift command line, as printed by a verbose build or given in an
+ * environment variable, into arguments.
+ *
+ * Paths on Windows use backslash separators, so a backslash there is literal
+ * unless it precedes a double quote (the `CommandLineToArgvW` rules). Single
+ * quotes, which SwiftPM uses to quote arguments on every platform, keep their
+ * content literal. Elsewhere shell quoting applies.
+ *
+ * @param {String} commandString Command line
+ * @param {String} [platform] Platform name, defaults to process.platform
+ * @returns {Array<String>} Arguments
+ */
+export declare function splitSwiftCommandArgs(commandString: string, platform?: string): Array<string>;
 /**
  * Method to perform swift build in verbose mode.
  *
+ * `SWIFT_BUILD_ARGS` adds arguments to the build, for example
+ * `--build-system native` to use the llbuild engine with Swift 6.4.
+ *
  * @param {String} basePath Path
  * @returns {undefined|String} Verbose build output
  */
 export declare function verboseBuild(basePath: string): undefined | string;
 /**
- * Method to parse the verbose swift build output to identify key compiler parameters.
+ * Reduce one module's compiler invocation to the arguments that affect how
+ * its sources are type-checked.
+ *
+ * Only known argument classes are kept, so outputs, incremental build
+ * bookkeeping, response files, and flags a SourceKit build may not know are
+ * dropped. The order of the kept arguments is preserved, which keeps paired
+ * clang arguments such as `-Xcc -I -Xcc <path>` intact. The module cache is
+ * dropped as well: the build's cache may hold modules of other toolchains.
+ *
+ * @param {Array<String>} tokens Tokenized compiler invocation
+ * @returns {Array<String>} Sanitized compiler arguments
+ */
+export declare function sanitizeSwiftModuleArgs(tokens: Array<string>): Array<string>;
+/**
+ * Extract the per-module compiler invocations printed by a verbose swift
+ * build.
+ *
+ * Both engines print one driver invocation per module that carries
+ * `-module-name`: llbuild prints `swiftc ... -module-name X ... @sources`,
+ * while the Swift Build engine prints `builtin-SwiftDriver -- swiftc ...
+ * -module-name X ... @<target>.SwiftFileList`. llbuild also prints the
+ * frontend jobs of each module, which are only used when no driver line is
+ * found. Package manifest and plugin compilations are skipped.
+ *
+ * @param {String} buildOutput Verbose build output
+ * @param {String} [platform] Platform that printed the output, which decides
+ *   its quoting rules; defaults to process.platform
+ * @returns {Object} Map of module name to `{ args, sources, isDriver }`
+ */
+export declare function parseSwiftModuleInvocations(buildOutput: string, platform?: string): Object;
+/**
+ * Parse the llbuild engine's build description
+ * (`.build/<triple>/debug/description.json`).
+ *
+ * Its `swiftCommands` record every Swift module the build compiled, with the
+ * exact source list and compiler arguments. Host-tool variants
+ * (`...-tool.module`, built for macros and plugins) are used only when a
+ * module has no regular variant.
+ *
+ * @param {Object} descriptionJson Parsed description.json
+ * @returns {Object} Map of module name to `{ args, sources, isDriver }`
+ */
+export declare function parseSwiftBuildDescription(descriptionJson: Object): Object;
+/**
+ * Merge the sanitized arguments of several modules into one argument list,
+ * used when a source file cannot be attributed to a single module. The first
+ * module's single-value flags win, include paths accumulate, and `-Xcc`
+ * values are merged per clang argument group.
+ *
+ * @param {Array<Array<String>>} argLists Sanitized argument lists, most relevant first
+ * @returns {Array<String>} Merged arguments
+ */
+export declare function mergeSwiftModuleArgs(argLists: Array<Array<string>>): Array<string>;
+/**
+ * Method to parse the verbose swift build output to identify key compiler
+ * parameters. The arguments of the root package's modules are merged, or of
+ * every module when the root modules are unknown.
  *
  * @param {String} buildOutput Verbose build output
- * @returns {Object} compiler build parameters
+ * @param {Array<String>|Set<String>} [rootModules] Module names of the root package
+ * @returns {Object} `{ params, compilerArgs }` where params maps module names to their arguments
  */
-export declare function extractCompilerParamsFromBuild(buildOutput: string): Object;
+export declare function extractCompilerParamsFromBuild(buildOutput: string, rootModules?: Array<string> | Set<string>): Object;
 /**
  * Method to index a swift file and extract metadata
  *
  * @param {String} filePath Path to .swift file
- * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @param {String|Array<string>} compilerArgs Compiler arguments. They should
+ *   list every source of the file's module so that references across files
+ *   resolve; the file itself is appended when missing.
+ * @param {Object} [env] Environment overrides for sourcekitten
  * @returns {undefined|Object} metadata
  */
-export declare function index(filePath: string, compilerArgs: string | Array<string>): undefined | Object;
+export declare function index(filePath: string, compilerArgs: string | Array<string>, env?: Object): undefined | Object;
 /**
  * Parse the data from the index command
  *
+ * Besides the symbol names and lines, the unified symbol resolution (USR) of
+ * every indexed entity is recorded with its lines. A USR identifies the
+ * declaration the compiler resolved a reference to, including the module
+ * that declares it, which is what attributes a usage to a dependency.
+ *
  * @param {Object} indexJson Json from the index command
  * @returns {Object|undefined} Parsed value
  */
 export declare function parseIndex(indexJson: Object): Object | undefined;
+/**
+ * Identify the module that declares an entity from its demangled name.
+ *
+ * Qualified names start with the module (`Yams.dump(object:...)`), and
+ * members declared in extensions carry the extending module
+ * (`(extension in Yams):Swift.String.yaml`), which is what a usage of the
+ * member depends on.
+ *
+ * @param {String} demangled Output of `swift demangle --compact`
+ * @returns {undefined|String} Module name
+ */
+export declare function moduleFromDemangledName(demangled: string): undefined | string;
+/**
+ * Identify the module of a mangled Swift name without the demangler. Only the
+ * leading module context is decoded, so extension members are attributed to
+ * the extended type's module.
+ *
+ * @param {String} mangled Mangled name starting with `$s`
+ * @returns {undefined|String} Module name
+ */
+export declare function moduleFromMangledPrefix(mangled: string): undefined | string;
+/**
+ * Identify the declaring module of each USR.
+ *
+ * Swift USRs are demangled in one batch with `swift demangle`; clang module
+ * references (`c:@M@<module>`, emitted for import declarations) carry the
+ * module name directly. Other clang USRs name no module and are skipped.
+ *
+ * @param {Array<String>} usrs USRs to resolve
+ * @param {String} basePath Directory to run the demangler in
+ * @returns {Map<String, String>} USR to module name
+ */
+export declare function resolveUsrModules(usrs: Array<string>, basePath: string): Map<string, string>;
 /**
  * Method to execute dump-package package command.
  *
@@ -61,9 +231,10 @@ export declare function parseDumpPackage(dumpJson: Object): Object | undefined;
  *
  * @param {String} moduleName Module name
  * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @param {Object} [env] Environment overrides for sourcekitten
  * @returns {undefined|Object} JSON representation of the swift module or undefined.
  */
-export declare function moduleInfo(moduleName: string, compilerArgs: string | Array<string>): undefined | Object;
+export declare function moduleInfo(moduleName: string, compilerArgs: string | Array<string>, env?: Object): undefined | Object;
 /**
  * Parse the data from module-info command to replicate the swift interface
  *
@@ -72,32 +243,126 @@ export declare function moduleInfo(moduleName: string, compilerArgs: string | Ar
  */
 export declare function parseModuleInfo(moduleInfoJson: Object): Object | undefined;
 /**
- * Method to collect the build symbols from the output file maps generated by swift build.
+ * Method to collect the build symbols from the output file maps generated by
+ * swift build.
+ *
+ * Both build engines are supported: the llbuild engine writes per-module
+ * `output-file-map.json` files, while the Swift Build engine (default from
+ * Swift 6.4) writes per-target `<target>-OutputFileMap.json` files under
+ * `.build/out/Intermediates.noindex`.
  *
  * @param {String} basePath Path
  * @param {Object} options CLI options
- * @returns {Object} symbols map
+ * @param {Array<String>} [fileMaps] Output file maps, found under basePath when omitted
+ * @returns {Object} symbols map keyed by module name
  */
-export declare function collectBuildSymbols(basePath: string, options: Object): Object;
+export declare function collectBuildSymbols(basePath: string, options: Object, fileMaps?: Array<string>): Object;
 /**
- * Method to parse output file map to identify the module and their symbols.
- * This list is imprecise when compared with the data from module-info command.
+ * Method to parse output file map to identify the module, its sources, and
+ * their symbols. The symbol list is imprecise; the sources are exact.
+ *
+ * The module name is derived from the containing directory for llbuild maps
+ * (`<Module>.build` and, since Swift 6.4, `<Module>-tool.build`) and from the
+ * file name for Swift Build maps (`<target>-OutputFileMap.json`, where the
+ * target name still needs to be sanitised into a module name).
  *
  * @param filemap {String} File name
- * @returns {Object} parsed module metadata
+ * @returns {Object} parsed module metadata `{ moduleName, moduleSymbols, sourceFiles }`
  */
 export declare function parseOutputFileMap(filemap: string): Object;
+/**
+ * Parse `.build/workspace-state.json` into the dependency packages of the
+ * workspace and the directory each one was materialised in.
+ *
+ * @param {Object} stateJson Parsed workspace-state.json
+ * @param {String} basePath Root package directory
+ * @returns {Array<Object>} `{ identity, name, location, kind, dir }` per package
+ */
+export declare function parseSwiftWorkspaceState(stateJson: Object, basePath: string): Array<Object>;
+/**
+ * Parse the Swift Build engine's project model (`.build/manifest.pif`) into
+ * the module names each package declares.
+ *
+ * The manifest is a list of workspace, project, and target objects linked
+ * through their `signature` hashes. A project's guid is `PACKAGE:<identity>`
+ * and each target records its `PRODUCT_MODULE_NAME`. Unlike the verbose
+ * build output, the manifest lists modules whose compilation never started,
+ * which keeps the module-to-package mapping complete when a build fails.
+ *
+ * @param {Array} manifestJson Parsed manifest.pif contents
+ * @returns {Object} Map of package identity to module names
+ */
+export declare function parseSwiftBuildManifest(manifestJson: any[]): Object;
+/**
+ * Collect the modules imported by a Swift source file, with their lines.
+ *
+ * Declarations such as `@testable import Foo`, `public import Foo`,
+ * `@_implementationOnly import cmark_gfm`, and `import struct Foo.Bar` are
+ * recognised; comments, string literals, and `canImport` conditions are not
+ * imports.
+ *
+ * @param {String} sourceText Swift source
+ * @returns {Array<Object>} `{ module, line }` per import declaration
+ */
+export declare function parseSwiftImports(sourceText: string): Array<Object>;
+/**
+ * Collect the clang module names declared at the top level of a module map.
+ *
+ * @param {String} moduleMapText module.modulemap contents
+ * @returns {Object} `{ modules, headerPaths }`
+ */
+export declare function parseClangModuleMap(moduleMapText: string): Object;
+/**
+ * Build a description of every module in a completed swift build: its
+ * compiler arguments, sources, and owning package.
+ *
+ * Arguments come from the llbuild build description when present and from
+ * the verbose build output otherwise (the only source for the Swift Build
+ * engine); sources come from the same places or from the output file maps.
+ * Packages come from `workspace-state.json`, and every module is attributed
+ * to the package whose directory holds its sources. Clang modules are
+ * discovered through their module maps.
+ *
+ * @param {String} basePath Root package directory
+ * @param {String} buildOutput Verbose build output
+ * @param {Object} options CLI options
+ * @param {Object} [rootMetadata] Parsed dump-package of the root package
+ * @returns {Object} `{ modules, packages, root, clangModules, fileMaps }`
+ */
+export declare function collectSwiftBuildPlan(basePath: string, buildOutput: string, options: Object, rootMetadata?: Object): Object;
+/**
+ * Check that sourcekitten can load SourceKit, with a trivial syntax request.
+ *
+ * A missing binary, a binary without its Swift runtime (`error while loading
+ * shared libraries: libswiftCore.so`), or one linked against a different
+ * Swift runtime than the toolchain provides (Linux has no stable Swift ABI, so
+ * such a binary crashes inside libswiftCore) fails every request; the probe
+ * turns that into one clear message instead of silent empty results.
+ *
+ * @param {Object} [env] Environment overrides for sourcekitten
+ * @returns {boolean} `true` when sourcekitten answered the probe
+ */
+export declare function isSourcekittenUsable(env?: Object): boolean;
 /**
  * Create a precise semantics slices file for a swift project.
  *
+ * The project is built once in verbose mode. Every source file of the root
+ * package's (non-test) modules is then indexed with sourcekitten using that
+ * module's own compiler arguments and source list, with sourcekitten aligned
+ * to the toolchain that compiled the project. The declaring module of every
+ * resolved reference is recovered from its USR, which attributes each usage
+ * to the package that provides the module (`moduleReferences`).
+ *
  * @param basePath basePath Path
  * @param options options CLI options
  */
 export declare function createSemanticsSlices(basePath: any, options: any): {
+    projectPath: any;
+    toolchain: any;
     packageMetadata: Object | undefined;
+    packages: any;
+    packageModules: {};
     buildSymbols: Object;
-    moduleInfos: {};
-    fileStructures: {};
     fileIndexes: {};
 } | undefined;
 //# sourceMappingURL=swiftsem.d.ts.map

package/types/lib/evinser/swiftsem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swiftsem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/swiftsem.js"],"names":[],"mappings":"AAwEA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,GAAC,MAAM,CAI5B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAHjC,MAGiC,GAF/B,MAAM,GAAC,SAAS,CAiB5B;AAqCD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,SAAO,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,QAAA,GAF7C,MAAM,CA+JlB;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,QAAQ,QAAA,EAAE,YAAY,EAHjC,SAAO,KAAK,CAAC,MAAM,CAGc,GAF/B,SAAS,GAAC,MAAM,CAc5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAHzB,MAGyB,GAFvB,MAAM,GAAC,SAAS,CA6B5B;AAsED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,QAAA,GAFvB,SAAS,GAAC,MAAM,CAY5B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,MAAM,GAAC,SAAS,CA4B5B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,QAAA,EAAE,YAAY,EAHxC,SAAO,KAAK,CAAC,MAAM,CAGqB,GAFtC,SAAS,GAAC,MAAM,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAHnC,MAGmC,GAFjC,MAAM,GAAC,SAAS,CAqF5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,QAAA,EAAE,OAAO,EAH1C,MAG0C,GAFxC,MAAM,CAkBlB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,QAAA,GAF7B,MAAM,CAgBlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA;;;;;;cAoGtD"}
+{"version":3,"file":"swiftsem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/swiftsem.js"],"names":[],"mappings":"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"}