@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/src/config.ts

@@ -1,12 +1,6 @@
-import {
-  CONTRACT_VERSION,
-  type Confidence,
-  type Format,
-  type Language,
-  type Severity,
-} from "./contract/contract.generated.ts";
-import type { ExemptionClass } from "./exempt-classes.ts";
-import { LANGUAGE, PRODUCT } from "./product.ts";
+import type { ResolvedConfig } from "./contract/config.generated.ts";
+import { SEVERITIES, type Severity } from "./contract/contract.generated.ts";
+import { LANGUAGE } from "./product.ts";
 
 /**
  * The name of the repository configuration at the target root, which is also the
@@ -15,254 +9,32 @@ import { LANGUAGE, PRODUCT } from "./product.ts";
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
 
-/**
- * Whether the target is an application, whose every caller is in the analyzed
- * graph, or a library, whose published API has callers outside it.
- */
-export type TargetKind = "application" | "library";
+export type { PartialConfig, ResolvedConfig } from "./contract/config.generated.ts";
 
-/** The target kind as a source writes it: one kind for every language, or one per language. */
-export type TargetKindSetting = TargetKind | { readonly go: TargetKind; readonly ts: TargetKind };
+/** Whether the target is an application or a library. */
+export type TargetKind = Extract<ResolvedConfig["target"]["kind"], string>;
+export type DeclarationEntry = ResolvedConfig["ts"]["serializers"][number];
+export type LifecycleContract = ResolvedConfig["ts"]["lifecycle_contracts"][number];
+export type BuildConfiguration = ResolvedConfig["analysis"]["configurations"][number];
+export type ProjectConfiguration = Extract<BuildConfiguration, { readonly project: string }>;
+export type TemplateDelimiters = ResolvedConfig["analysis"]["template_delimiters"];
+export type Sort = ResolvedConfig["reporters"]["sort"];
+export type Cascade = ResolvedConfig["reporters"]["cascade"];
 
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting: TargetKindSetting, language: Language): TargetKind {
-  return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind: ResolvedConfig["target"]["kind"]): TargetKind {
+  return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
 
-/** Whether declarations in generated files are analyzed. */
-export type GeneratedFiles = "exclude" | "include";
-
-/** How a reference from a consumer's test file counts. */
-export type ConsumerTests = "test" | "production";
-
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK: Readonly<Record<Severity, number>> = { allow: 0, warn: 1, deny: 2 };
-
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity: Severity, failOn: Severity): boolean {
-  return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-
-/** The order findings are rendered in. */
-export type Sort = "position" | "size";
-
-/** How much of a dead component a rendering names. */
-export type Cascade = "roots" | "full";
-
-/**
- * A platform configuration: an operating system, an architecture and the build
- * tags in effect. It is the shape a language built under build constraints reads,
- * and this analyzer leaves it to that analysis.
- */
-interface PlatformConfiguration {
-  readonly shape: "platform";
-  readonly id: string;
-  readonly os: string;
-  readonly arch: string;
-  readonly tags: readonly string[];
-}
-
-/**
- * A project configuration: one compiler configuration file, as a path below the
- * target root with `/` between segments.
- */
-export interface ProjectConfiguration {
-  readonly shape: "project";
-  readonly id: string;
-  readonly project: string;
-}
-
-/**
- * One entry of the build matrix: a configuration the target builds under, in
- * exactly one of the two shapes the matrix admits.
- */
-export type BuildConfiguration = PlatformConfiguration | ProjectConfiguration;
-
-/**
- * The pair of action delimiters a template is parsed with. Both members are
- * required once a document names the object, so the pair is one setting rather
- * than two.
- */
-export interface TemplateDelimiters {
-  readonly left: string;
-  readonly right: string;
-}
-
-/** How the analysis is scoped and filtered. */
-export interface Analysis {
-  readonly languages: readonly Language[];
-  readonly minConfidence: Confidence;
-  readonly generatedFiles: GeneratedFiles;
-  readonly consumerTests: ConsumerTests;
-  readonly configurations: readonly BuildConfiguration[];
-  readonly matrixComplete: boolean;
-  readonly templateDirs: readonly string[];
-  readonly templateDelimiters: TemplateDelimiters;
-}
-
-/** How findings are rendered. */
-interface Reporters {
-  readonly formats: readonly Format[];
-  readonly sort: Sort;
-  readonly cascade: Cascade;
-  readonly maxFindings: number;
-  readonly failOn: Severity;
-}
-
-/**
- * One declaration a configuration entry names, in exactly one of three shapes: a
- * declaration of the analyzed program by its stable symbol reference, a declaration a
- * module exports by the bare specifier an import writes for the module and the
- * declaration's path from its exports, or a declaration of the global scope by its
- * path from that scope. A path joins the name and each member with dots and spells a
- * static member with `:static` after it.
- */
-export type DeclarationEntry =
-  | { readonly shape: "symbol"; readonly symbol: string }
-  | { readonly shape: "module"; readonly module: string; readonly name: string }
-  | { readonly shape: "global"; readonly global: string };
-
-/**
- * One framework's lifecycle contract: the declarations whose use makes a class one of
- * the framework's components, the classes whose subclasses are its components, and the
- * names of the members the framework calls on a component, each spelled as the last
- * component of a member's stable symbol reference.
- */
-export interface LifecycleContract {
-  readonly components: readonly DeclarationEntry[];
-  readonly bases: readonly DeclarationEntry[];
-  readonly members: readonly string[];
-}
-
-/**
- * One analyzer the orchestrator may run, in exactly one of two shapes: an installed
- * analyzer, named by its command alone, or an acquirable one, which also names the
- * artifact acquisition fetches and verifies. This analyzer validates and prints the
- * list and runs nothing from it.
- */
-export type Provider =
-  | {
-      readonly shape: "installed";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-    }
-  | {
-      readonly shape: "acquirable";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-      readonly source: string;
-      readonly version: string;
-      readonly digest: string;
-    };
-
-/** The analyzers the orchestrator runs. */
-interface Providers {
-  readonly analyzers: readonly Provider[];
-}
-
-/** The section the TypeScript analyzer owns. */
-export interface TSSection {
-  readonly testFiles: readonly string[];
-  readonly entryFiles: readonly string[];
-  readonly componentExtensions: readonly string[];
-  readonly disabledConventions: readonly string[];
-  readonly injectionRegistrations: readonly DeclarationEntry[];
-  readonly lifecycleContracts: readonly LifecycleContract[];
-  readonly serializers: readonly DeclarationEntry[];
-  /** Whether the maintainer declares the roots the analysis finds every root the target has. */
-  readonly rootsComplete: boolean;
-}
-
-/**
- * The resolved configuration: the closed key list of the Contract's
- * configuration schema, decoded, with every default applied.
- *
- * `targetKind` is empty exactly in the configuration every default states, which
- * is not a configuration a run may use: the field has no default and resolution
- * refuses a result that carries none.
- *
- * `severity` is a map rather than an object because its keys come from a
- * document, and an object keyed by document text answers for names it never
- * held. The order it is written in is the emitter's, not the map's.
- */
-export interface Config {
-  readonly contractVersion: string;
-  readonly targetKind: TargetKindSetting | "";
-  readonly analysis: Analysis;
-  readonly consumersComplete: boolean;
-  readonly rootPatterns: readonly string[];
-  readonly severity: ReadonlyMap<string, Severity>;
-  readonly exemptionsDisabled: readonly ExemptionClass[];
-  readonly reporters: Reporters;
-  readonly providers: Providers;
-  readonly ts: TSSection;
-}
-
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig(): Config {
-  return {
-    contractVersion: CONTRACT_VERSION,
-    targetKind: "",
-    analysis: {
-      languages: [],
-      minConfidence: "probable",
-      generatedFiles: "exclude",
-      consumerTests: "test",
-      configurations: [],
-      matrixComplete: false,
-      templateDirs: [],
-      templateDelimiters: { left: "{{", right: "}}" },
-    },
-    consumersComplete: false,
-    rootPatterns: [],
-    severity: new Map(),
-    exemptionsDisabled: [],
-    reporters: {
-      formats: ["text"],
-      sort: "position",
-      cascade: "roots",
-      maxFindings: 0,
-      failOn: "deny",
-    },
-    providers: {
-      analyzers: [
-        { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-        { shape: "installed", name: PRODUCT, languages: [LANGUAGE], command: PRODUCT },
-      ],
-    },
-    ts: {
-      testFiles: [
-        "**/*.test.{ts,tsx,mts,cts}",
-        "**/*.test-d.{ts,tsx,mts,cts}",
-        "**/*.spec-d.{ts,tsx,mts,cts}",
-        "**/*.spec.*",
-        "**/__tests__/**",
-        "**/__mocks__/**",
-        "**/test-d/**",
-      ],
-      entryFiles: [],
-      componentExtensions: [".vue", ".svelte", ".astro"],
-      disabledConventions: [],
-      injectionRegistrations: [],
-      lifecycleContracts: [],
-      serializers: [],
-      rootsComplete: false,
-    },
-  };
+  return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 
 /** Where a resolved setting came from, in the order the sources outrank each other. */
 export type Source = "flag" | "repository" | "central" | "default";
 
-/**
- * One setting's source together with the file or flag that supplied it. `label`
- * is empty exactly when `source` is `"default"`.
- */
+/** One setting's source with the file or flag that supplied it, empty for a default. */
 export interface Origin {
   readonly source: Source;
   readonly label: string;
@@ -277,63 +49,24 @@ export function renderOrigin(origin: Origin): string {
 }
 
 /**
- * The origin of each resolved setting, keyed by the setting's dotted path. A
- * section holds no value of its own and has no entry; the severity object
- * carries one entry per code it names, or the entry `severity` alone when it is
- * empty.
+ * The origin of each resolved setting, keyed by the setting's dotted path. A section
+ * has no entry; a keyed section carries one entry per member it names, or one for
+ * itself when it is empty.
  */
 export type Provenance = ReadonlyMap<string, Origin>;
 
-/**
- * The configuration documents one invocation reads, each the document's text or
- * absent. `repositoryLabel` names the document `repository` holds and
- * `centralLabel` the one `central` holds; `flagLabels` names the flag that
- * supplied each setting `flags` names, keyed by dotted setting path.
- */
-export interface Inputs {
-  readonly flags?: string;
-  readonly repository?: string;
-  readonly central?: string;
-  readonly repositoryLabel?: string;
-  readonly centralLabel?: string;
-  readonly flagLabels?: ReadonlyMap<string, string>;
+/** One configuration document: its text and the path it was read from. */
+export interface Document {
+  readonly text: string;
+  readonly label: string;
 }
 
-/** Which refusal a {@link ConfigError} carries. */
-type ErrorKind =
-  /**
-   * A document that is not one JSON instance of the closed key list: a syntax
-   * error, a value of the wrong type, a value outside the closed set a key
-   * declares, or a member written twice at one level.
-   */
-  | "malformed"
-  /**
-   * A key the closed key list does not declare, or a severity key naming no live
-   * kind or a kind whose severity the Contract fixes.
-   */
-  | "unimplemented-key"
-  /** A resolved configuration no source supplied a target kind for. */
-  | "missing-target-kind";
-
 /**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
+ * The configuration sources one invocation carries. `flags` holds the text each
+ * setting option was given, by the setting's dotted path.
  */
-export class ConfigError extends Error {
-  /** Which refusal this is. */
-  readonly kind: ErrorKind;
-
-  /**
-   * The key or field the message names, spelled as the document spells it. It is
-   * empty when the refusal names none.
-   */
-  readonly key: string;
-
-  constructor(kind: ErrorKind, key: string, message: string) {
-    super(message);
-    this.name = "ConfigError";
-    this.kind = kind;
-    this.key = key;
-  }
+export interface Inputs {
+  readonly flags?: ReadonlyMap<string, string>;
+  readonly repository?: Document;
+  readonly central?: Document;
 }

package/src/configuration-files.ts

@@ -24,7 +24,13 @@ import type { SourceFiles } from "./source-files.ts";
 import { bytewise } from "./text/compare.ts";
 import { isRecord } from "./json-document.ts";
 import { filesIn } from "./fs/tree.ts";
-import { holdsManifest, inInstalledPackages, manifestAt, readJSON } from "./fs/manifest.ts";
+import {
+  DEPENDENCY_SECTIONS,
+  holdsManifest,
+  inInstalledPackages,
+  manifestAt,
+  readJSON,
+} from "./fs/manifest.ts";
 import { shellWords } from "./text/shell.ts";
 
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -40,14 +46,6 @@ const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[]
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
 
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"] as const;
 
@@ -474,7 +472,7 @@ export function declaredIn(host: Host, dir: string): readonly string[] {
     return [];
   }
   const names = new Set<string>();
-  for (const member of DEPENDENCY_MEMBERS) {
+  for (const member of DEPENDENCY_SECTIONS) {
     const section = value[member];
     if (isRecord(section)) {
       Object.keys(section).forEach((name) => names.add(name));

package/src/configured-declarations.ts

@@ -19,7 +19,7 @@ import {
 import { SymbolFlags, type NodeHandle, type Symbol as TSSymbol } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
-import type { Config, DeclarationEntry } from "./config.ts";
+import type { DeclarationEntry, ResolvedConfig } from "./config.ts";
 import { declaredComponent, type Inventory } from "./inventory.ts";
 import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
@@ -252,21 +252,21 @@ export function resolveEntries<Brand>(
   }
   const modules = modulesNamed(
     project,
-    new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))),
+    new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))),
   );
   return entries.map((entry) => {
-    if (entry.shape === "symbol") {
+    if ("symbol" in entry) {
       return { entry, handles: new Set<string>(), ids: new Set(byRef.get(entry.symbol) ?? []) };
     }
     const { components, static: isStatic } = componentsOf(
-      entry.shape === "module" ? entry.name : entry.global,
+      "module" in entry ? entry.name : entry.global,
     );
     const [first = "", ...rest] = components;
     let start: TSSymbol | undefined;
     if (isStatic && rest.length === 0) {
       // Only a member is static, and a path of one component names no member.
       start = undefined;
-    } else if (entry.shape === "module") {
+    } else if ("module" in entry) {
       const module = modules.get(entry.module);
       start = module === undefined ? undefined : memberOf(project, module, first, false);
     } else if (nameComponent(first) === first) {
@@ -329,14 +329,10 @@ export function entriesAt<Brand>(
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry: DeclarationEntry, held: Inventory): string {
-  switch (entry.shape) {
-    case "symbol":
-      return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-    case "module":
-      return entry.name;
-    case "global":
-      return entry.global;
+  if ("symbol" in entry) {
+    return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
   }
+  return "module" in entry ? entry.name : entry.global;
 }
 
 /** One entry of a configuration key that names a declaration, and the key's dotted path. */
@@ -353,14 +349,17 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  * the injection registrations, each lifecycle contract's components and then its bases,
  * and the serializers.
  */
-export function configuredDeclarations(config: Config): readonly ConfiguredDeclaration[] {
+export function configuredDeclarations(config: ResolvedConfig): readonly ConfiguredDeclaration[] {
   return [
-    ...config.ts.injectionRegistrations.map((entry) => ({
+    ...config.ts.injection_registrations.map((entry) => ({
       key: "ts.injection_registrations",
       entry,
     })),
-    ...config.ts.lifecycleContracts.flatMap((contract) =>
-      [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry })),
+    ...config.ts.lifecycle_contracts.flatMap((contract) =>
+      [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+        key: LIFECYCLE_KEY,
+        entry,
+      })),
     ),
     ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
   ];
@@ -396,12 +395,8 @@ export function declarationsNamed<Brand>(
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry: DeclarationEntry): string {
-  switch (entry.shape) {
-    case "symbol":
-      return entry.symbol;
-    case "module":
-      return `${entry.module}#${entry.name}`;
-    case "global":
-      return `#${entry.global}`;
+  if ("symbol" in entry) {
+    return entry.symbol;
   }
+  return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }

package/src/consumers.ts

@@ -1,60 +1,9 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-
-import type { Config } from "./config.ts";
-import { consumerProjects } from "./discover.ts";
+import type { PartialConfig } from "./config.ts";
 import type { Host } from "./host.ts";
-import { inventory, packageScope } from "./inventory.ts";
+import { inventory } from "./inventory.ts";
 import { relativePath } from "./paths.ts";
 import { references, type ConsumerSide, type Reference } from "./references.ts";
-import type { Module, Scope } from "./scope.ts";
-import { narrowedTo, type Engine, type ProjectView } from "./session.ts";
-
-/** One consumer the run loaded. */
-export interface LoadedConsumer {
-  /** The name the consumer publishes itself under, which every finding names it by. */
-  readonly id: string;
-  /** The consumer's directory, absolute. */
-  readonly path: string;
-}
-
-/** One declared consumer and the compiler configurations it opens as. */
-interface ConsumerLoad {
-  readonly consumer: LoadedConsumer;
-  /** The configuration files, absolute, in discovery order, none a target project's. */
-  readonly configFiles: readonly string[];
-}
-
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host: Host, module: Module): string {
-  return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(
-  engine: Engine,
-  host: Host,
-  scope: Scope,
-  targetConfigFiles: readonly string[],
-): readonly ConsumerLoad[] {
-  const opened = new Set(targetConfigFiles);
-  return scope.consumers.map((module) => {
-    const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-      const fresh = !opened.has(configFile);
-      opened.add(configFile);
-      return fresh;
-    });
-    return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-  });
-}
+import { narrowedTo, type ProjectView } from "./session.ts";
 
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
@@ -68,7 +17,7 @@ export function consumerReferences<Brand>(
   host: Host,
   targetRoot: string,
   consumer: ConsumerSide,
-  config: Config,
+  config: PartialConfig,
 ): readonly Reference[] {
   const held = inventory(
     narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined),
@@ -76,10 +25,10 @@ export function consumerReferences<Brand>(
     targetRoot,
   );
   const found = references(project, held, targetRoot, {
-    testFiles: config.ts.testFiles,
+    testFiles: config.ts.test_files,
     consumer,
   }).references;
-  if (config.analysis.consumerTests !== "production") {
+  if (config.analysis.consumer_tests !== "production") {
     return found;
   }
   return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));