@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/roots/unseen-loads.ts

@@ -0,0 +1,345 @@
+/**
+ * The loads by a computed path: those whose files the analysis resolves, and those it
+ * cannot, whose files are roots the analysis does not see, so the configuration's roots
+ * are never complete.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isMetaProperty,
+  isNoSubstitutionTemplateLiteral,
+  isPropertyAccessExpression,
+  isStringLiteral,
+  isTemplateExpression,
+  SyntaxKind,
+  type CallExpression,
+  type Identifier,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { amdLoadOf, amdUnresolved } from "../amd.ts";
+import { membersNamed, textsOf, writtenValue, type Value } from "../entries/static-module.ts";
+import { writtenName } from "../platform-calls.ts";
+import {
+  cannotStartPackageName,
+  dirnamePath,
+  hasURLScheme,
+  isAbsolutePath,
+  relativePath,
+  resolvePath,
+  startsRelativePath,
+} from "../paths.ts";
+import type { Position } from "../position.ts";
+import { unwrapped } from "../unwrap.ts";
+import { globExpression } from "../text/glob.ts";
+
+/** One load the analysis cannot resolve, in the configuration whose production file writes it. */
+export interface UnseenLoad {
+  readonly configuration: string;
+  /** The position of the call. */
+  readonly position: Position;
+}
+
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+function leadingLiteral(node: Node): string | undefined {
+  const at = unwrapped(node);
+  if (isTemplateExpression(at)) {
+    return at.head.text;
+  }
+  if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+    const left = unwrapped(at.left);
+    return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+      ? left.text
+      : leadingLiteral(at.left);
+  }
+  return undefined;
+}
+
+/**
+ * The directory below `dir` a computed load's leading literal names, every file of which
+ * the load reaches, or none where it names a package, `dir` itself or a directory holding
+ * it, each of which would name every sibling.
+ */
+function computedLoadDirectory(dir: string, prefix: string): string | undefined {
+  if (!startsRelativePath(prefix) || !prefix.endsWith("/")) {
+    return undefined;
+  }
+  const target = resolvePath(dir, prefix);
+  return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+
+/** One `import()`, `require()` or `import.meta.glob()` call, and the declaration whose code writes it. */
+export interface LoadCall {
+  readonly call: CallExpression;
+  readonly from: string;
+}
+
+/** One file a computed load may load, by its id. */
+interface Loadable {
+  readonly file: SourceFile;
+  readonly fileId: string;
+}
+
+/** One load by a computed path whose files the analysis resolves. */
+export interface ComputedLoad {
+  readonly call: CallExpression;
+  readonly from: string;
+  /** The name a `require()` call is written with; {@link callsPlatform} owns which one loads. */
+  readonly require: Identifier | undefined;
+  /** Whether the call is an AMD `define` or `require` (references-ts.37). */
+  readonly amd: boolean;
+  readonly files: readonly Loadable[];
+  /** Whether the load reads each file as text or as a URL, which references no declaration of it. */
+  readonly asset: boolean;
+  /**
+   * Whether the analysis names every file the load may load. An unresolved load names none,
+   * and leaves the configuration's roots incomplete (confidence.26).
+   */
+  readonly resolved: boolean;
+  /**
+   * Whether the load is an eager glob, which Vite turns into static imports at the top of
+   * the calling module (https://vite.dev/guide/features.html#glob-import), so the file
+   * evaluates what it loads wherever the call is written.
+   */
+  readonly eager: boolean;
+}
+
+/** Whether one node is a call that may load a module by a computed path. */
+export function isLoadCall(node: Node): node is CallExpression {
+  if (!isCallExpression(node)) {
+    return false;
+  }
+  return (
+    node.expression.kind === SyntaxKind.ImportKeyword ||
+    writtenName(node.expression) !== undefined ||
+    isMetaGlob(node)
+  );
+}
+
+/**
+ * The files one `import.meta.glob` call loads, as Vite's `toAbsoluteGlob` reads its globs
+ * (https://vite.dev/guide/features.html#glob-import): `/` against the project root, `./`
+ * and `../` against a literal `base` (read against the root where it starts with `/`) or the
+ * calling file's directory, `**` as written, and `!` removing what it matches. Undefined
+ * where Vite reads a glob through an alias, the root is unknown, or a glob or base is computed.
+ */
+function globbed(
+  file: SourceFile,
+  first: Node,
+  options: Node | undefined,
+  others: readonly Loadable[],
+  rootOf: (fileName: string) => string | undefined,
+): readonly Loadable[] | undefined {
+  const patterns = textsOf(writtenValue(first), true);
+  const bases = globOption(options, "base");
+  const [written, ...more] = bases ?? [];
+  const base = written === undefined ? undefined : textsOf(written, false);
+  if (
+    patterns === undefined ||
+    bases === undefined ||
+    more.length > 0 ||
+    (written !== undefined && base === undefined)
+  ) {
+    return undefined;
+  }
+  const dir = dirnamePath(file.fileName);
+  const root = (): string | undefined => rootOf(file.fileName);
+  const against = (at: string): string | undefined => {
+    if (!isAbsolutePath(at)) {
+      return resolvePath(dir, at);
+    }
+    const top = root();
+    return top === undefined ? undefined : resolvePath(top, `.${at}`);
+  };
+  const from = base?.[0] === undefined ? dir : against(base[0]);
+  const keep: RegExp[] = [];
+  const drop: RegExp[] = [];
+  for (const written of patterns) {
+    const negated = written.startsWith("!");
+    const pattern = negated ? written.slice(1) : written;
+    let path: string | undefined;
+    if (isAbsolutePath(pattern)) {
+      path = against(pattern);
+    } else if (startsRelativePath(pattern)) {
+      path = from === undefined ? undefined : resolvePath(from, pattern);
+    } else if (pattern.startsWith("**")) {
+      path = pattern;
+    }
+    if (path === undefined) {
+      return undefined;
+    }
+    (negated ? drop : keep).push(globExpression(path));
+  }
+  return others.filter(
+    (candidate) =>
+      keep.some((glob) => glob.test(candidate.file.fileName)) &&
+      !drop.some((glob) => glob.test(candidate.file.fileName)),
+  );
+}
+
+/**
+ * The computed loads among one file's load calls, each loading the `candidates` but the
+ * file itself: an `import()` or `require()` whose path starts with a relative literal naming
+ * a directory below the file's loads every candidate below it, as a bundler's context module
+ * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
+ * call of a computed path that names no such directory and no package is an unresolved load,
+ * and so is an AMD call one of whose dependencies names no path ({@link amdUnresolved}).
+ */
+export function computedLoadsOf(
+  file: SourceFile,
+  calls: readonly LoadCall[],
+  candidates: readonly Loadable[],
+  rootOf: (fileName: string) => string | undefined,
+): readonly ComputedLoad[] {
+  const dir = dirnamePath(file.fileName);
+  const others = candidates.filter((candidate) => candidate.file !== file);
+  return calls.flatMap(({ call, from }): ComputedLoad[] => {
+    const [first, options] = call.arguments;
+    if (first === undefined) {
+      return [];
+    }
+    if (isMetaGlob(call)) {
+      const files = globbed(file, first, options, others, rootOf);
+      const asset = readsAsAsset(options);
+      return [
+        {
+          call,
+          from,
+          require: undefined,
+          amd: false,
+          files: files ?? [],
+          resolved: files !== undefined,
+          asset,
+          eager: isEager(options),
+        },
+      ];
+    }
+    const amd = amdLoadOf(call);
+    if (amd !== undefined) {
+      return amdUnresolved(amd)
+        ? [
+            {
+              call,
+              from,
+              require: amd.callee,
+              amd: true,
+              files: [],
+              resolved: false,
+              asset: false,
+              eager: false,
+            },
+          ]
+        : [];
+    }
+    const argument = unwrapped(first);
+    const require =
+      call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
+    if (!mayNamePath(argument)) {
+      return [];
+    }
+    const prefix = leadingLiteral(argument);
+    if (namesPackage(prefix)) {
+      return [];
+    }
+    const target = prefix === undefined ? undefined : computedLoadDirectory(dir, prefix);
+    const files =
+      target === undefined
+        ? []
+        : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
+    return [
+      {
+        call,
+        from,
+        require,
+        amd: false,
+        files,
+        resolved: target !== undefined,
+        asset: false,
+        eager: false,
+      },
+    ];
+  });
+}
+
+/**
+ * Whether a computed argument may be a module path: anything but a string, which names its
+ * module, and a value no path is, a number, a boolean, `null`, an object, an array, a
+ * function or a class.
+ */
+function mayNamePath(argument: Node): boolean {
+  return !NO_PATH.has(argument.kind);
+}
+
+const NO_PATH: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.StringLiteral,
+  SyntaxKind.NoSubstitutionTemplateLiteral,
+  SyntaxKind.NumericLiteral,
+  SyntaxKind.BigIntLiteral,
+  SyntaxKind.TrueKeyword,
+  SyntaxKind.FalseKeyword,
+  SyntaxKind.NullKeyword,
+  SyntaxKind.ObjectLiteralExpression,
+  SyntaxKind.ArrayLiteralExpression,
+  SyntaxKind.ArrowFunction,
+  SyntaxKind.FunctionExpression,
+  SyntaxKind.ClassExpression,
+  SyntaxKind.RegularExpressionLiteral,
+]);
+
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node: CallExpression): boolean {
+  if (!isPropertyAccessExpression(node.expression)) {
+    return false;
+  }
+  const { expression, name } = node.expression;
+  return (
+    isIdentifier(name) &&
+    name.text === "glob" &&
+    isMetaProperty(expression) &&
+    expression.keywordToken === SyntaxKind.ImportKeyword
+  );
+}
+
+/** The values the options of an `import.meta.glob` write for one key, undefined where a spread may hide one. */
+function globOption(options: Node | undefined, key: string): readonly Value[] | undefined {
+  return options === undefined ? [] : membersNamed(writtenValue(options), key);
+}
+
+/** Whether the options of an `import.meta.glob` set `eager` to `true`. */
+function isEager(options: Node | undefined): boolean {
+  return (
+    globOption(options, "eager")?.some((value) => value.kind === "boolean" && value.value) === true
+  );
+}
+
+/** The query parameters that make Vite load a file as its text or its URL, each written bare. */
+const ASSET_QUERY = /(?:^\?|&)(?:raw|url|inline)(?:&|$)/u;
+
+/**
+ * Whether the options of an `import.meta.glob` read each file as text or as a URL: a
+ * `query` string holding a bare `raw`, `url` or `inline`, or an `as` of `raw` or `url`,
+ * which Vite reads as that query (https://vite.dev/guide/features.html#glob-import). Any
+ * other query is read as loading the module, which keeps more than it may.
+ */
+function readsAsAsset(options: Node | undefined): boolean {
+  const texts = (key: string): readonly string[] =>
+    (globOption(options, key) ?? []).flatMap((value) =>
+      value.kind === "text" ? [value.text] : [],
+    );
+  return (
+    texts("as").some((text) => text === "raw" || text === "url") ||
+    texts("query").some((text) => ASSET_QUERY.test(text.startsWith("?") ? text : `?${text}`))
+  );
+}
+
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix: string | undefined): boolean {
+  return (
+    prefix !== undefined &&
+    prefix !== "" &&
+    !cannotStartPackageName(prefix) &&
+    !hasURLScheme(prefix)
+  );
+}

package/src/run.ts

@@ -1,9 +1,13 @@
-import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
-import { DiscoveryError, renderDiagnostic } from "./discover.ts";
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.ts";
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.ts";
+import { REPOSITORY_DOCUMENT, type Document, type Inputs } from "./config.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
-import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
-import { SetupError, setupLine } from "./setup-failure.ts";
+import { renderDiagnostic } from "./load/diagnostics.ts";
+import { FailureExit, failureLines, productFault } from "./failure.ts";
+import { readScope, scopeForDir, type Scope } from "./scope.ts";
+import { UsageError } from "./usage.ts";
 import { openEngine, type Engine, type EngineOptions } from "./session.ts";
 import { printConfigVerb } from "./verbs/print-config.ts";
 import { printProjectsVerb } from "./verbs/print-projects.ts";
@@ -12,8 +16,9 @@ import { printRootsVerb } from "./verbs/print-roots.ts";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.ts";
 import { describeVerb } from "./verbs/describe.ts";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.ts";
-import { EXIT_FAILURE, EXIT_USAGE, type Verb, type VerbOptions } from "./verbs/verb.ts";
+import { type Verb, type VerbOptions } from "./verbs/verb.ts";
 import { versionVerb } from "./verbs/version.ts";
+import { diagnose, message, PRODUCT } from "./product.ts";
 
 /** One output stream of the command line. `process.stdout` and `process.stderr` satisfy it. */
 export interface Writer {
@@ -36,7 +41,7 @@ const VERBS: readonly {
   { name: "version", run: versionVerb },
 ];
 
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 
 /**
  * The tokens whose presence in an option's name makes that option a request to
@@ -46,33 +51,16 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) =>
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"] as const;
 
 /**
- * Maps an option name to the setting of the Contract's configuration schema it supplies,
- * so one entry registers the option, supplies the document resolution reads, and gives
- * the spelling the setting's provenance names. The name is this command's vocabulary and
- * is never derived from the path: a setting reaches the command line only by an entry,
- * and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies:
+ * the options contract/settings.json names for a setting this analyzer reads.
  */
-export const SETTING_OPTIONS: ReadonlyMap<string, string> = new Map([
-  ["min-confidence", "analysis.min_confidence"],
-  ["sort", "reporters.sort"],
-  ["cascade", "reporters.cascade"],
-  ["max-findings", "reporters.max_findings"],
-  ["fail-on", "reporters.fail_on"],
-]);
+export const SETTING_OPTIONS: ReadonlyMap<string, string> = new Map(
+  SETTINGS.flatMap((row) => (row.option === undefined ? [] : [[row.option, row.key] as const])),
+);
 
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS: ReadonlySet<string> = new Set(["target", "config", "central", "scope"]);
 
-/**
- * The setting options whose value is an integer rather than a string. A value
- * written other than as digits is passed on as the string it is, so resolution
- * refuses it by its type rather than reading `1e2` as 100.
- */
-const INTEGER_OPTIONS: ReadonlySet<string> = new Set(["max-findings"]);
-
-/** An integer as an option writes it: an optional minus sign and digits alone. */
-const INTEGER_TEXT = /^-?[0-9]+$/u;
-
 /** One invocation's options, by name: the last value of each, and every value of a repeatable one. */
 interface Options {
   readonly named: ReadonlyMap<string, string>;
@@ -107,7 +95,7 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
   const repeated = new Map<string, string[]>();
   for (const arg of args) {
     if (!arg.startsWith("-")) {
-      throw new ConfigError("malformed", "", `unexpected argument ${JSON.stringify(arg)}`);
+      throw new UsageError(`unexpected argument ${JSON.stringify(arg)}`);
     }
     const [spelled, ...rest] = arg.split("=");
     const name = (spelled ?? "").replace(/^-+/u, "");
@@ -117,14 +105,10 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
       !own.plain.includes(name) &&
       !own.repeatable.includes(name)
     ) {
-      throw new ConfigError("malformed", "", `unknown option ${JSON.stringify(spelled ?? arg)}`);
+      throw new UsageError(`unknown option ${JSON.stringify(spelled ?? arg)}`);
     }
     if (rest.length === 0) {
-      throw new ConfigError(
-        "malformed",
-        "",
-        `option ${JSON.stringify(spelled ?? arg)} takes a value`,
-      );
+      throw new UsageError(`option ${JSON.stringify(spelled ?? arg)} takes a value`);
     }
     const value = rest.join("=");
     named.set(name, value);
@@ -133,51 +117,56 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
   return { named, repeated };
 }
 
-function readFileOr(host: Host, path: string, orUndefined: boolean): string | undefined {
+/** The document an option names. */
+function documentAt(host: Host, label: string): Document {
   try {
-    return host.readFile(resolvePath(host.workingDirectory(), path));
+    const path = resolvePath(host.workingDirectory(), label);
+    // A file past the bound reads as one byte more than it, which resolution refuses.
+    return { text: host.readFile(path, CONFIG_MAX_BYTES + 1), label };
   } catch (error: unknown) {
-    if (orUndefined) {
-      return undefined;
-    }
-    throw new ConfigError(
-      "malformed",
-      "",
-      `${path}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new UsageError(`${label}: ${message(error)}`);
   }
 }
 
 /**
- * The configuration documents one invocation reads: the repository configuration
- * at the target root or the path an option named, the central configuration, and
- * the settings the options supply as one flag document.
+ * The repository configuration at the target root, none where it is absent. One that
+ * cannot be read is a configuration document that cannot be, refused with the usage code.
+ */
+function repositoryAt(host: Host, target: string): Document | undefined {
+  const label = joinPath(target, REPOSITORY_DOCUMENT);
+  const root = resolvePath(host.workingDirectory(), target);
+  const text = readTargetDocument(
+    host,
+    root,
+    REPOSITORY_DOCUMENT,
+    label,
+    (named, reason) => new UsageError(`${named}: ${reason}`),
+  );
+  return text === undefined ? undefined : { text, label };
+}
+
+/**
+ * The configuration sources one invocation carries: the repository configuration at
+ * the target root or the path an option named, the central configuration, and the
+ * text each setting option was given.
  */
 function inputsOf(host: Host, options: Options): Inputs {
-  const target = options.named.get("target") ?? ".";
   const named = options.named.get("config");
-  const repositoryLabel = named ?? joinPath(target, REPOSITORY_DOCUMENT);
-  const repository = readFileOr(host, repositoryLabel, named === undefined);
+  const target = options.named.get("target") ?? ".";
+  const repository = named === undefined ? repositoryAt(host, target) : documentAt(host, named);
   const centralLabel = options.named.get("central");
-  const central = centralLabel === undefined ? undefined : readFileOr(host, centralLabel, false);
-
-  const flat: Record<string, unknown> = {};
-  const flagLabels = new Map<string, string>();
-  for (const [name, path] of SETTING_OPTIONS) {
+  const central = centralLabel === undefined ? undefined : documentAt(host, centralLabel);
+  const flags = new Map<string, string>();
+  for (const [name, key] of SETTING_OPTIONS) {
     const value = options.named.get(name);
-    if (value === undefined) {
-      continue;
+    if (value !== undefined) {
+      flags.set(key, value);
     }
-    flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
-    flagLabels.set(path, `--${name}`);
   }
-  const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);
-
   return {
-    ...(flags === undefined ? {} : { flags }),
-    ...(repository === undefined ? {} : { repository, repositoryLabel }),
-    ...(central === undefined || centralLabel === undefined ? {} : { central, centralLabel }),
-    flagLabels,
+    flags,
+    ...(repository === undefined ? {} : { repository }),
+    ...(central === undefined ? {} : { central }),
   };
 }
 
@@ -195,9 +184,7 @@ function scopeOf(host: Host, options: Options): Scope {
  * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
  * usage error, a requested source edit or a refused configuration, 3 for a failure that
  * produced no answer. It writes nothing outside `out` and `err` and never exits the
- * process. `host` is the platform the run reads, the version it reports included, and
- * `openClient` opens the compiler client; a caller that watches what a run reads
- * supplies its own of either.
+ * process. A caller that watches what a run reads supplies its own `host` or `openClient`.
  */
 export function run(
   args: readonly string[],
@@ -208,9 +195,7 @@ export function run(
 ): number {
   const editing = sourceEditOption(args);
   if (editing !== undefined) {
-    err.write(
-      `deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`,
-    );
+    diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
     err.write(USAGE);
     return EXIT_USAGE;
   }
@@ -227,7 +212,7 @@ export function run(
     );
   }
   if (name !== undefined) {
-    err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+    diagnose(err, `unknown verb ${JSON.stringify(name)}`);
   }
   err.write(USAGE);
   return EXIT_USAGE;
@@ -259,7 +244,7 @@ function invoke(
       openClient: (config) => {
         opened = openClient({
           collectTiming: false,
-          components: { extensions: config.ts.componentExtensions, host: streams.host },
+          components: { extensions: config.ts.component_extensions, host: streams.host },
         });
         return opened;
       },
@@ -270,29 +255,28 @@ function invoke(
   }
 }
 
-/** Turns one refusal into the exit code the Contract's table gives it. */
+/**
+ * Turns one refusal into the exit code the Contract's table gives it. An error no class names
+ * is a fault of this analyzer, printed with its stack for the maintainers it asks the user to
+ * report it to.
+ */
 function refuse(error: unknown, err: Writer): number {
-  if (error instanceof ConfigError) {
-    err.write(`deadset-ts: ${error.message}\n`);
+  if (error instanceof UsageError) {
+    diagnose(err, error.message);
     err.write(USAGE);
     return EXIT_USAGE;
   }
-  if (error instanceof DiscoveryError) {
-    for (const diagnostic of error.diagnostics) {
-      err.write(`${renderDiagnostic(diagnostic)}\n`);
+  if (!(error instanceof FailureExit)) {
+    if (error instanceof Error && error.stack !== undefined) {
+      err.write(`${error.stack}\n`);
     }
-    err.write(`deadset-ts: ${error.message}\n`);
-    return EXIT_FAILURE;
+    return refuse(productFault(`meets an error none of its classes names: ${message(error)}`), err);
   }
-  if (error instanceof SetupError) {
-    for (const failure of error.failures) {
-      err.write(`${setupLine(failure)}\n`);
-    }
-    return EXIT_FAILURE;
+  for (const diagnostic of error.diagnostics) {
+    err.write(`${renderDiagnostic(diagnostic)}\n`);
   }
-  if (error instanceof ScopeError) {
-    err.write(`deadset-ts: ${error.message}\n`);
-    return EXIT_FAILURE;
+  for (const line of failureLines(error.failures)) {
+    err.write(`${line}\n`);
   }
-  throw error;
+  return EXIT_FAILURE;
 }