@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/report.ts

@@ -13,18 +13,16 @@ import type {
   FindingPosition,
   PositionedSymbol,
 } from "./finding.ts";
+import type { AppliedConvention } from "./conventions.ts";
 import type { PassResult } from "./findings-pass.ts";
 import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
 
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "6.1.0";
+const SCHEMA_VERSION = "7.0.0";
 
-/**
- * Every report schema version this analyzer reads: the schema versions the Contract it
- * implements admits, each an instance of the one it writes.
- */
-export const SCHEMA_VERSIONS_ACCEPTED: readonly string[] = ["6.0.0", SCHEMA_VERSION];
+/** Every report schema version this analyzer reads: the one the Contract it implements admits. */
+export const SCHEMA_VERSIONS_ACCEPTED: readonly string[] = [SCHEMA_VERSION];
 
 /** The name this analyzer writes every document under and mints every identifier with. */
 export const ANALYZER_NAME = "deadset-ts";
@@ -151,6 +149,22 @@ export interface ReportNotBuilt {
   readonly error: string;
 }
 
+/** One type error that skipped the function or statement holding it. */
+export interface TypeErrorSkip {
+  /** The file holding the error, below the target root. */
+  readonly path: string;
+  readonly line: number;
+  /** The compiler's message, on one line. */
+  readonly message: string;
+}
+
+/** One configuration in which the checker left questions unanswered, with what they held. */
+export interface UnansweredCount {
+  readonly configuration: string;
+  readonly questions: number;
+  readonly declarations: number;
+}
+
 /** One consumer the run loaded, at the directory a report names it by. */
 interface ReportConsumer {
   readonly id: string;
@@ -201,6 +215,10 @@ export interface Report {
   readonly declared_gaps: readonly WireDeclaredGap[];
   readonly excluded_by_cgo: readonly never[];
   readonly test_file_rules: readonly TestFileRule[];
+  readonly type_error_skips: readonly TypeErrorSkip[];
+  readonly notes: readonly never[];
+  readonly unanswered_questions: readonly UnansweredCount[];
+  readonly conventions_applied: readonly AppliedConvention[];
   readonly totals: WireTotals;
 }
 
@@ -217,6 +235,10 @@ export interface ReportInput {
   readonly unavailable: readonly UnavailableConsumer[];
   readonly result: PassResult;
   readonly testFileRules: readonly TestFileRule[];
+  readonly typeErrorSkips: readonly TypeErrorSkip[];
+  readonly unanswered: readonly UnansweredCount[];
+  /** The convention rows the run applied, in the report's order. */
+  readonly conventionsApplied: readonly AppliedConvention[];
 }
 
 /** Two strings ordered bytewise. */
@@ -462,6 +484,34 @@ export function buildReport(input: ReportInput): Report {
     test_file_rules: [...input.testFileRules]
       .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
       .map((one) => ({ rule: one.rule, matched: one.matched })),
+    type_error_skips: [
+      ...new Map(
+        input.typeErrorSkips.map((one) => {
+          const skip = { path: one.path, line: one.line, message: one.message };
+          return [JSON.stringify(skip), skip] as const;
+        }),
+      ),
+    ]
+      .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+      .map(([, skip]) => skip),
+    notes: [],
+    unanswered_questions: [...input.unanswered]
+      .sort(
+        (a, b) =>
+          compare(a.configuration, b.configuration) ||
+          compare(JSON.stringify(a), JSON.stringify(b)),
+      )
+      .map((one) => ({
+        configuration: one.configuration,
+        questions: one.questions,
+        declarations: one.declarations,
+      })),
+    conventions_applied: input.conventionsApplied.map((one) => ({
+      name: one.name,
+      package: one.package,
+      version: one.version,
+      manifest: one.manifest,
+    })),
     totals: totalsOf(findings, input.result),
   };
 }

package/src/reporters/annotations.ts

@@ -37,11 +37,17 @@ function command(
   return `::${level} file=${escapeProperty(at.path)},line=${String(at.line)},col=${String(at.column)},endLine=${String(endLine)},title=${escapeProperty(title)}::${escapeData(message)}`;
 }
 
+/** The title and the message prefix of a type-error skip's annotation. */
+const SKIP_TITLE = "type error skipped";
+const SKIP_MESSAGE =
+  "the analysis did not evaluate the function or statement holding this type error: ";
+
 /**
  * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind. A finding at or above the
- * failing severity is an error and one below it a warning; a stale suppression is an error,
- * because its kind is fixed on at the failing severity.
+ * file, line, column and last line, titled by its code and kind, then one warning per
+ * type-error skip naming its file and line. A finding at or above the failing severity is
+ * an error and one below it a warning; a stale suppression is an error, because its kind
+ * is fixed on at the failing severity.
  */
 export function annotations(report: Report, options: RenderOptions): Iterable<string> {
   return coalesced(
@@ -64,6 +70,9 @@ export function annotations(report: Report, options: RenderOptions): Iterable<st
           stale.message,
         )}\n`;
       }
+      for (const skip of report.type_error_skips) {
+        yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
+      }
     })(),
   );
 }

package/src/reporters/template.ts

@@ -925,6 +925,9 @@ class Execution {
     if (head === undefined) {
       throw new RenderError("empty command");
     }
+    if (head.k === "lit" && head.value === null) {
+      throw new RenderError("nil is not a command");
+    }
     if (head.k !== "func") {
       if (rest.length > 0 || piped !== undefined) {
         throw new RenderError("cannot give an argument to a non-function");

package/src/resolve.ts

@@ -21,6 +21,7 @@ import {
   type TargetKind,
   type TemplateDelimiters,
 } from "./config.ts";
+import { CONVENTION_ROWS } from "./convention-rows.ts";
 import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.ts";
 import {
   checkDocument,
@@ -105,6 +106,8 @@ interface Doc {
   readonly providers: readonly Provider[] | undefined;
   readonly testFiles: readonly string[] | undefined;
   readonly entryFiles: readonly string[] | undefined;
+  readonly componentExtensions: readonly string[] | undefined;
+  readonly disabledConventions: readonly string[] | undefined;
   readonly injectionRegistrations: readonly DeclarationEntry[] | undefined;
   readonly lifecycleContracts: readonly LifecycleContract[] | undefined;
   readonly serializers: readonly DeclarationEntry[] | undefined;
@@ -259,24 +262,63 @@ function readStrings<T extends string>(
     );
   }
   const seen = new Set<string>();
-  for (const entry of value as unknown[]) {
+  for (const [index, entry] of (value as unknown[]).entries()) {
+    const at = `${path}[${String(index)}]`;
     if (typeof entry !== "string") {
-      throw malformed(label, path, "holds an entry that is not a string");
+      throw malformed(label, at, "is not a string");
     }
     if (entry === "") {
-      throw malformed(label, path, "holds an empty entry");
+      throw malformed(label, at, "is empty");
     }
     if (seen.has(entry)) {
-      throw malformed(label, path, `names ${JSON.stringify(entry)} twice`);
+      throw malformed(label, at, `names ${JSON.stringify(entry)} again`);
     }
     if (allowed !== undefined && !(allowed as readonly string[]).includes(entry)) {
-      throw malformed(label, path, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
+      throw malformed(label, at, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
     }
     seen.add(entry);
   }
   return value as readonly T[];
 }
 
+/** A component file's extension: a full stop followed by letters and digits. */
+const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
+
+function readComponentExtensions(
+  ts: Record<string, unknown> | undefined,
+  label: string,
+): readonly string[] | undefined {
+  const extensions = readStrings(ts, "component_extensions", "ts.component_extensions", label, 0);
+  const wrong = extensions?.findIndex((one) => !COMPONENT_EXTENSION.test(one)) ?? -1;
+  if (extensions !== undefined && wrong !== -1) {
+    throw malformed(
+      label,
+      `ts.component_extensions[${String(wrong)}]`,
+      `${JSON.stringify(extensions[wrong])} is not a full stop followed by letters and digits`,
+    );
+  }
+  return extensions;
+}
+
+/** The names of the convention rows this analyzer's table carries. */
+const CONVENTION_NAMES: ReadonlySet<string> = new Set(CONVENTION_ROWS.map((row) => row.name));
+
+function readDisabledConventions(
+  ts: Record<string, unknown> | undefined,
+  label: string,
+): readonly string[] | undefined {
+  const names = readStrings(ts, "disabled_conventions", "ts.disabled_conventions", label, 0);
+  const unknown = names?.findIndex((one) => !CONVENTION_NAMES.has(one)) ?? -1;
+  if (names !== undefined && unknown !== -1) {
+    throw malformed(
+      label,
+      `ts.disabled_conventions[${String(unknown)}]`,
+      `${JSON.stringify(names[unknown])} names no convention row this analyzer carries`,
+    );
+  }
+  return names;
+}
+
 function requireMember(value: string | undefined, path: string, label: string): string {
   if (value === undefined || value === "") {
     throw malformed(label, path, "is required and names nothing");
@@ -792,6 +834,8 @@ function readDoc(value: unknown, label: string): Doc {
     providers: readProviders(providers, label),
     testFiles: readStrings(ts, "test_files", "ts.test_files", label, 1),
     entryFiles: readStrings(ts, "entry_files", "ts.entry_files", label, 0),
+    componentExtensions: readComponentExtensions(ts, label),
+    disabledConventions: readDisabledConventions(ts, label),
     injectionRegistrations: readDeclarations(
       ts,
       "injection_registrations",
@@ -986,13 +1030,13 @@ export function resolve(inputs: Inputs): { config: Config; provenance: Provenanc
 }
 
 /**
- * The build matrix the configuration documents resolve to, every document read and
- * refused as {@link resolve} refuses it, and nothing else required of them: which
- * projects a run analyzes depends on the matrix alone, so a question about the
- * projects asks no target kind.
+ * The configuration the documents resolve to, every document read and refused as
+ * {@link resolve} refuses it, with no target kind required of them: which projects a
+ * run analyzes does not depend on the kind, so a question about the projects asks
+ * none. The kind is empty where no document names one.
  */
-export function resolveMatrix(inputs: Inputs): readonly BuildConfiguration[] {
-  return settleAll(inputs).config.analysis.configurations;
+export function resolveUnkinded(inputs: Inputs): Config {
+  return settleAll(inputs).config;
 }
 
 /**
@@ -1076,6 +1120,16 @@ function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Or
     ts: {
       testFiles: at("ts.test_files", defaults.ts.testFiles, (doc) => doc.testFiles),
       entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
+      componentExtensions: at(
+        "ts.component_extensions",
+        defaults.ts.componentExtensions,
+        (doc) => doc.componentExtensions,
+      ),
+      disabledConventions: at(
+        "ts.disabled_conventions",
+        defaults.ts.disabledConventions,
+        (doc) => doc.disabledConventions,
+      ),
       injectionRegistrations: at(
         "ts.injection_registrations",
         defaults.ts.injectionRegistrations,

package/src/roots.ts

@@ -10,29 +10,44 @@
 
 import type { SourceFile } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.ts";
+import type { ParseFile } from "./configuration-files.ts";
+import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import { globExpression } from "./glob.ts";
+import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
+import { typeQueryAliases } from "./type-query-alias.ts";
 
 /** Why one declaration is a root. */
 export type RootKind =
   /** A file `ts.entry_files` names, and what it exports. */
   | "entry-file"
+  /** A file an applied convention row's globs match, and what it exports. */
+  | "convention"
   /** A file the manifest names as an importable entry point, and what it exports outside the published API. */
   | "manifest-entry"
   /** A file the manifest names as a command, and what it exports outside the published API. */
   | "manifest-binary"
+  /** A file a token of a manifest's script names, and what it exports. */
+  | "script"
+  /**
+   * A global a declaration file declares as an alias of a module's export, and the
+   * module declarations around it: a use of the global is a use of the export.
+   */
+  | "type-query-alias"
   /** A declaration a consumer of a library target can name. */
   | "published-api"
   /** A declaration an exact reference from the configuration names. */
   | "configured"
   /** A declaration a pattern from the configuration names. */
   | "pattern"
+  /** A declaration of a function or statement a type error skipped, and what it may have selected. */
+  | "type-error"
   /** A file a tool or the platform enters by its own convention, and what it exports where the tool reads it. */
   | EntryRule;
 
@@ -81,18 +96,36 @@ export interface Roots {
 
 /** What decides the roots beside the declarations themselves. */
 export interface RootOptions {
+  /** The platform the configuration files beside the program are read from. */
+  readonly host: Host;
   /** The target's own manifest. */
   readonly manifest: Manifest;
+  /**
+   * The entry points the other packages of the target's workspace name, each already
+   * marked published or not by its own manifest's rule.
+   */
+  readonly workspaceEntries?: readonly ManifestEntry[] | undefined;
   /** `roots.patterns` from the resolved configuration. */
   readonly patterns: readonly string[];
   /** `ts.entry_files` from the resolved configuration. */
   readonly entryFiles: readonly string[];
+  /** The convention rows the run applied. */
+  readonly conventions?: Conventions | undefined;
   /** `ts.test_files` from the resolved configuration. */
   readonly testFiles: readonly string[];
+  /** The parser the configuration files no program holds are read with, where they are read. */
+  readonly parse?: ParseFile | undefined;
   /** Whether the target is a library, so a consumer outside it reaches its published API. */
   readonly publishedAPI: boolean;
 }
 
+/** The kind of root each role of a manifest entry makes. */
+const ENTRY_KINDS = {
+  import: "manifest-entry",
+  run: "manifest-binary",
+  script: "script",
+} as const satisfies Record<ManifestEntry["role"], RootKind>;
+
 /** Whether a configured string carries either special character. */
 function isPattern(text: string): boolean {
   return text.includes("*") || text.includes("?");
@@ -204,19 +237,24 @@ export function roots<Brand>(
   };
 
   const published: SourceFile[] = [];
-  const publishes = (entry: ManifestEntry): boolean =>
-    options.publishedAPI &&
-    entry.published &&
-    (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
-  for (const entry of options.manifest.entries) {
-    if (publishes(entry)) {
+  const entries = [
+    ...options.manifest.entries.map((entry) => ({
+      entry,
+      publishes:
+        entry.published &&
+        (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
+    })),
+    ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+  ];
+  for (const { entry, publishes } of entries) {
+    if (options.publishedAPI && publishes) {
       published.push(...files.named(entry.path));
     }
   }
   const publishedNames = new Set(published.map((file) => file.fileName));
-  for (const entry of options.manifest.entries) {
+  for (const { entry } of entries) {
     for (const file of files.named(entry.path)) {
-      const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+      const kind = ENTRY_KINDS[entry.role];
       enter(file, kind, entry.member, !publishedNames.has(file.fileName));
     }
   }
@@ -228,9 +266,32 @@ export function roots<Brand>(
       }
     }
   }
-  for (const point of entryPoints(project, files, options.testFiles)) {
+  for (const { file, row } of options.conventions === undefined
+    ? []
+    : conventionEntries(options.conventions, files)) {
+    enter(file, "convention", row, true);
+  }
+  for (const point of entryPoints(
+    project,
+    files,
+    options.testFiles,
+    options.host,
+    targetRoot,
+    options.parse,
+  )) {
     enter(point.file, point.rule, point.source, point.exports);
   }
+  for (const file of files.byPath.values()) {
+    for (const alias of typeQueryAliases(file)) {
+      const source = alias.type.getText().replace(/\s+/gu, " ");
+      for (const node of [alias.declaration, ...alias.containers]) {
+        const id = declared.get(nodeKey(file, node));
+        if (id !== undefined) {
+          add(id, "type-query-alias", source);
+        }
+      }
+    }
+  }
 
   const { tables: exportsOf, answered } = exportTables(project, held, [
     ...entered.filter((entry) => entry.exports).map((entry) => entry.file),

package/src/run.ts

@@ -4,7 +4,8 @@ import { EMITTERS } from "./findings/emitters.ts";
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
 import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
-import { openEngine, type Engine } from "./session.ts";
+import { SetupError, setupLine } from "./setup-failure.ts";
+import { openEngine, type Engine, type EngineOptions } from "./session.ts";
 import { printConfigVerb } from "./verbs/print-config.ts";
 import { printProjectsVerb } from "./verbs/print-projects.ts";
 import { printRetainedVerb } from "./verbs/print-retained.ts";
@@ -204,7 +205,7 @@ export function run(
   out: Writer,
   err: Writer,
   host: Host,
-  openClient: (collectTiming: boolean) => Engine = (collectTiming) => openEngine({ collectTiming }),
+  openClient: (options: EngineOptions) => Engine = openEngine,
 ): number {
   const editing = sourceEditOption(args);
   if (editing !== undefined) {
@@ -243,7 +244,7 @@ function invoke(
   own: VerbOptions,
   args: readonly string[],
   streams: { readonly out: Writer; readonly err: Writer; readonly host: Host },
-  openClient: (collectTiming: boolean) => Engine,
+  openClient: (options: EngineOptions) => Engine,
 ): number {
   let options: Options | undefined;
   const read = (): Options => (options ??= readOptions(args, own));
@@ -256,8 +257,11 @@ function invoke(
       scope: () => scopeOf(streams.host, read()),
       option: (name) => read().named.get(name),
       repeated: (name) => read().repeated.get(name) ?? [],
-      openClient: (collectTiming) => {
-        opened = openClient(collectTiming);
+      openClient: (config) => {
+        opened = openClient({
+          collectTiming: false,
+          components: { extensions: config.ts.componentExtensions, host: streams.host },
+        });
         return opened;
       },
       emitters: EMITTERS,
@@ -282,6 +286,12 @@ function refuse(error: unknown, err: Writer): number {
     err.write(`deadset-ts: ${error.message}\n`);
     return EXIT_FAILURE;
   }
+  if (error instanceof SetupError) {
+    for (const failure of error.failures) {
+      err.write(`${setupLine(failure)}\n`);
+    }
+    return EXIT_FAILURE;
+  }
   if (error instanceof ScopeError) {
     err.write(`deadset-ts: ${error.message}\n`);
     return EXIT_FAILURE;

package/src/schema.ts

@@ -102,6 +102,8 @@ export const SCHEMA_ROOT: KeyNode = {
       members: {
         test_files: leaf,
         entry_files: leaf,
+        component_extensions: leaf,
+        disabled_conventions: leaf,
         injection_registrations: declarations,
         lifecycle_contracts: {
           kind: "list",