@asmlift/core 0.8.0 → 0.9.0

package/src/cdecl/spell.ts

@@ -0,0 +1,69 @@
+// asmlift — the PRINTER of what the parser reads: a declared type in asmlift's type vocabulary
+// (`ParamType`): `u8 *`, `void (*)(s32 channel)`, `f32 (*)[3]`, and every run of tokens a spelling
+// holds, as written.
+//
+// The derivations come from the parser (`parse.ts`), listed from the declarator's name outward, so
+// the printer rebuilds the abstract declarator from the inside: a pointer is written ahead of what it
+// binds, an array or a function after it, and a pointer that an array or a function binds next is
+// grouped in parentheses.
+//
+// A RUN OF TOKENS IS PRINTED AS WRITTEN, one space wherever the source separates two of them: a type's
+// name (`A::B`, `TVec3<const u8 *>`), a member pointer's class, a function's parameter list and an
+// array's extent alike. A function pointer's own parameters are part of its spelling, not types this
+// reads.
+import type { Tokens } from './lex';
+import type { DeclaredType, Range } from './parse';
+
+/** The type `t` spells: its qualifiers, its base and its abstract declarator, `const u8 *`. */
+export function spellType(t: DeclaredType, tokens: Tokens): string {
+  const base = t.qualifiers.length === 0 ? t.spelling : [...t.qualifiers, t.spelling].filter((w) => w !== '').join(' ');
+  let declarator = '';
+  // whether the last derivation was written ahead: an array or a function after it groups it in parentheses
+  let prefixed = false;
+  // whether the declarator is only the extents and lists written straight after the absent name
+  let suffixes = true;
+  for (const d of t.derivations) {
+    if (d.kind === 'pointer' || d.kind === 'reference') {
+      const own =
+        d.kind === 'reference' ? '&' : [`${d.member !== undefined ? `${d.member}::` : ''}*`, ...d.qualifiers].join(' ');
+      // a pointer is a word kept apart from what it binds, `u8 * *`, unless that is the name's own suffix
+      declarator = declarator === '' || suffixes ? own + declarator : `${own} ${declarator}`;
+      prefixed = true;
+      suffixes = false;
+    } else {
+      const grouped = prefixed ? `(${declarator})` : declarator;
+      declarator =
+        d.kind === 'array'
+          ? `${grouped}[${d.size === undefined ? '' : written(tokens, d.size)}]`
+          : `${grouped}(${written(tokens, d.list)})`;
+      prefixed = false;
+    }
+  }
+  return declarator === '' ? base : `${base} ${declarator}`;
+}
+
+/** A parameter's type as C adjusts it: an array nearest the name is a pointer to what it holds, and a
+ *  function nearest the name a pointer to it. `f32 m[2][3]` is `f32 (*)[3]`, and `int fn(int)` is
+ *  `int (*)(int)`. */
+export function asParameter(t: DeclaredType): DeclaredType {
+  const [first, ...rest] = t.derivations;
+  if (first?.kind === 'array') {
+    return { ...t, derivations: [{ kind: 'pointer', qualifiers: [] }, ...rest] };
+  }
+  if (first?.kind === 'function') {
+    return { ...t, derivations: [{ kind: 'pointer', qualifiers: [] }, ...t.derivations] };
+  }
+  return t;
+}
+
+/** The tokens of `r` as written, one space wherever the source separates two of them. */
+export function written(tokens: Tokens, r: Range): string {
+  let out = '';
+  for (let k = r.from; k < r.to; k++) {
+    if (k > r.from && tokens.start(k) > tokens.end(k - 1)) {
+      out += ' ';
+    }
+    out += tokens.text(k);
+  }
+  return out;
+}

package/src/codegen-flags.ts

@@ -117,6 +117,9 @@ interface OptionSpec {
   /** the value the compiler acts on, from the spelled one (the argument, else the pattern's last
    *  capture group, else empty) */
   value?: (spelled: string, m: Match) => string;
+  /** an inert word that makes the compiler STOP REPORTING after a number of errors; a run that
+   *  reads a rejection compiles without it (cli flags.ts) */
+  limitsErrors?: true;
 }
 
 const toggle = (_: string, m: Match) => (m[1] ? 'off' : 'on');
@@ -140,6 +143,12 @@ const gccFamily: OptionSpec[] = [
   // -Os sets optimize_size beside level 2, so it is its own level: agbcc hoist.c differs at `-O2` and
   // `-Os`, where the address load moves above the branch.
   { match: '-Os', slot: 'O', value: () => 's' },
+  // Error limits, ahead of the `-W` diagnostics: gcc stops at the first error under
+  // `-Wfatal-errors` and at N under `-fmax-errors=N`; clang takes both and spells its own
+  // `-ferror-limit=N`, and under `-Wfatal-errors` prints the first error as `fatal error:` with no
+  // trailer, so what it printed never says whether it was all.
+  { match: '-Wfatal-errors', limitsErrors: true },
+  { match: /^-f(?:max-errors|error-limit)=\d+$/, limitsErrors: true },
   ...cppAndDiagnostics,
   // -B tells the driver where its own programs are: which compiler runs is the toolchain, not a flag
   { match: /^-B(.+)$/ },
@@ -192,7 +201,10 @@ const TABLES: Record<FlagFamily, readonly OptionSpec[]> = {
     // both, and `mwccLevel` reads what a sequence of them compiles at.
     { match: /^-O((?:[0-4](?:,[ps])?|[ps])?)$/, slot: 'O' },
     { match: /^-[ID](.+)$/ },
-    { match: /^-(d|D|i|I|ir|maxerrors|w|msgstyle)$/, takesArg: true },
+    { match: /^-(d|D|i|I|ir|w|msgstyle)$/, takesArg: true },
+    // Under `-maxerrors 1` mwcc 2.3.3 and 2.4.2 end EVERY rejection with `User break, cancelled...`,
+    // a file with exactly one error included, so what they printed never says whether it was all.
+    { match: '-maxerrors', takesArg: true, limitsErrors: true },
     { match: /^-(nodefaults|nosyspath|nostdinc|stderr|c|multibyte|requireprotos)$/ },
     // `-dialect | -lang keyword` is one option under two names (mwcceppc -help), and all four
     // spellings compile the same source to the same object in the container.
@@ -307,6 +319,9 @@ export interface CodegenProfile {
   overriddenAt: readonly number[];
   /** argv indices of every inert word and its argument */
   inertAt: readonly number[];
+  /** argv indices of every error-limit word and its argument, a subset of `inertAt`: what a compiler
+   *  cut short printed is a prefix of its verdict (compiler-diagnostics.ts `verdictMessages`) */
+  errorLimitAt: readonly number[];
   /** argv indices of every word that is neither an option nor an option's argument, such as the file
    *  a compile command names or `-` for standard input; each is also unclassified */
   operandAt: readonly number[];
@@ -421,6 +436,7 @@ export function parseFlags(family: FlagFamily, argv: readonly string[]): Codegen
   const lastAt = new Map<string, { at: number[]; spelled: string }>();
   const overriddenAt: number[] = [];
   const inertAt: number[] = [];
+  const errorLimitAt: number[] = [];
   const overrides: LevelReading['overrides'] = [];
   const mwccLevelWords: { at: number; word: string }[] = [];
   const spans: number[][] = [];
@@ -482,6 +498,9 @@ export function parseFlags(family: FlagFamily, argv: readonly string[]): Codegen
     spans.push(at);
     if (hit.spec.slot === undefined) {
       inertAt.push(...at);
+      if (hit.spec.limitsErrors) {
+        errorLimitAt.push(...at);
+      }
       continue;
     }
     const slot = typeof hit.spec.slot === 'string' ? hit.spec.slot : hit.spec.slot(hit.m);
@@ -557,6 +576,7 @@ export function parseFlags(family: FlagFamily, argv: readonly string[]): Codegen
     unclassified,
     overriddenAt: overriddenAt.sort((a, b) => a - b),
     inertAt,
+    errorLimitAt,
     operandAt: unknown.filter((k) => isOperand(argv[k])),
     spans: grouped,
     overrides: overrides.sort((a, b) => a.at - b.at).map((o) => o.line),
@@ -617,14 +637,26 @@ export function storedFlags(family: FlagFamily, argv: readonly string[]): string
  *  option, and only mwcc has a C++ front end, so every other family answers `c` unless its unit is
  *  named for C++ — which none is, and where one is, real.ts refuses the row by name. */
 export function unitLanguage(unit: string, cflags: readonly string[]): 'c' | 'c++' {
-  const stated = parseFlags('mwcc', cflags).slots.lang;
+  return dialectOf(parseFlags('mwcc', cflags).slots.lang, unit);
+}
+
+/** A `-lang` word CodeWarrior does not accept. */
+export class UnreadableDialectError extends Error {}
+
+/** The dialect a `-lang` word states — the one reading of it, for `unitLanguage` and for the target
+ *  `targetFor` resolves at a flag set. With no word, the unit's extension when there is a unit, C
+ *  otherwise. `objc` is C to this reading: its functions are C's. A word CodeWarrior itself refuses
+ *  is refused. */
+export function dialectOf(stated: string | undefined, unit?: string): 'c' | 'c++' {
   if (stated === undefined) {
-    return /\.(cc|cp|cpp|cxx)$/i.test(unit) ? 'c++' : 'c';
+    return unit !== undefined && /\.(cc|cp|cpp|cxx)$/i.test(unit) ? 'c++' : 'c';
   }
-  if (stated !== 'c' && stated !== 'c++' && stated !== 'ec++') {
-    throw new Error(`${unit}: CodeWarrior dialect '${stated}' is not one of c, c++, ec++`);
+  if (stated !== 'c' && stated !== 'c++' && stated !== 'ec++' && stated !== 'objc') {
+    throw new UnreadableDialectError(
+      `${unit === undefined ? '' : `${unit}: `}CodeWarrior dialect '${stated}' is not one of c, c++, ec++, objc`,
+    );
   }
-  return stated === 'c' ? 'c' : 'c++';
+  return stated === 'c++' || stated === 'ec++' ? 'c++' : 'c';
 }
 
 /** The optimisation level the compiler acts on (`-O2`, `-O4,p`), or null when the flags name none and

package/src/compiler-diagnostics.ts

@@ -0,0 +1,194 @@
+// asmlift — reading a compiler's diagnostic text: which lines are errors, and when two failed
+// compiles failed THE SAME WAY. Pure string logic (core is browser-pure): the ranking drivers, the
+// benchmark's compile modules and the CLI read a compiler's output through here, so "an error"
+// means one thing on all of them.
+
+/** A scorer's refusal that IS the compiler's verdict: it ran to completion, exited nonzero and
+ *  said why. Everything else a scorer throws — a timeout, a killed process, a missing binary, a
+ *  differ that could not find the symbol — is this machine or this harness having a bad minute,
+ *  and says nothing about the candidate.
+ *
+ *  A CLASS because the distinction cannot be read back off a message: a compiler killed mid-run
+ *  has already printed half its diagnostics, and that text has exactly the shape of a rejection.
+ *  The seam that saw the spawn result is the only place that knows, so it says so in the type.
+ *
+ *  `diagnostic` is the compiler's WHOLE output. `message` is what the seam publishes, which may be
+ *  a bounded selection of it; a comparison made over a bounded selection compares the bound. */
+export class CompilerRejection extends Error {
+  readonly diagnostic: string;
+  constructor(message: string, diagnostic: string = message, options?: ErrorOptions) {
+    super(message, options);
+    this.name = 'CompilerRejection';
+    this.diagnostic = diagnostic;
+  }
+}
+
+/** The FIRST class word a line carries, with the colon that makes it a tag: `warning:`, `note:`,
+ *  `error:`, `fatal error:`, IDO's `Fatal:` and its numbered `Warning 712:`. The first, because a
+ *  message can quote a tag of its own — `expected ';' before 'note' token; note: …` is an error.
+ *  A line is ADVISORY when its tag is a warning or a note: the compiler may still accept the text. */
+const TAG = /\b(?:fatal(?:\s+error)?|error|warning|note)\b(?:\s+\d+)?\s*:/i;
+const isAdvisory = (line: string): boolean => {
+  const tag = TAG.exec(line);
+  return tag !== null && /^(?:warning|note)/i.test(tag[0]);
+};
+/** An mwcc caret line (`#   Error:      ^`). It carries no message: the line(s) after it do, and
+ *  together they are one diagnostic. */
+const MWCC_CARET = /#\s*(Error|Warning):[\s^~]*$/i;
+/** A line of an mwcc diagnostic's MESSAGE: `#`, then prose. Not the caret, not a source excerpt
+ *  (`#      12: x = y;`), not the banner (`### mwcceppc.exe Compiler:`, `#    File: …`, `# ----`).
+ *  mwcc wraps a message at the terminal's width, so a message is every such line up to the first
+ *  that is not one: a conversion error's source type ends one line and its target type `'int *'`
+ *  opens the next, and the first line alone equals the same conversion to `'int'`. */
+const MWCC_MESSAGE = /^\s*#(?!#)\s*(?!(?:Error|Warning)\s*:|\d+:|File:|-{3,})\S/i;
+
+/** `lines` with every ERROR ahead of every warning and note, each class in its original order.
+ *
+ *  A compiler prints diagnostics in source order, and a candidate that casts its way through a
+ *  project's types can print dozens of warnings above the one error that refused it. Whatever
+ *  bounds the list downstream then keeps warnings only, and the reader is shown a cause that is
+ *  not why the compile failed. An mwcc message travels with its caret line, whichever class that
+ *  is. */
+export function errorsFirst(lines: readonly string[]): string[] {
+  const errors: string[] = [];
+  const advisories: string[] = [];
+  /** the class of the mwcc diagnostic whose message lines are still arriving */
+  let open: boolean | undefined;
+  for (const l of lines) {
+    let advisory: boolean;
+    if (open !== undefined && MWCC_MESSAGE.test(l)) {
+      advisory = open;
+    } else {
+      advisory = isAdvisory(l);
+      open = MWCC_CARET.test(l) ? advisory : undefined;
+    }
+    (advisory ? advisories : errors).push(l);
+  }
+  return [...errors, ...advisories];
+}
+
+/** `file:line:` or `file:line:column:` opening a diagnostic, the gcc family's spelling (clang's
+ *  too). Behind an optional wrapper, because a seam's message puts its own words ahead of the
+ *  first line (`agbcc failed: c.c:12: …`). */
+const LOCATED = /(?:^|\s)[^\s:]+:\d+:(?:\d+:)?\s*(.*)$/;
+/** The word a located error may carry ahead of its message (gcc 3+, clang); pre-3.0 gcc has none. */
+const ERROR_TAG = /^(?:fatal\s+)?error\s*:\s*/i;
+/** An error spelled with the word and no `file:line:`: `cc1: error: …`, `ld: fatal error: …`, and
+ *  IDO's `cfe: Error: c.c, line 12: …`, whose own position is dropped with the rest. */
+const TAGGED = /\b(?:fatal(?:\s+error)?|error)\s*:\s*(?:\S+, line \d+:\s*)?(.*)$/i;
+/** Lines that belong to a diagnostic without being one: where the OTHER declaration was, and
+ *  pre-3.0 gcc's two-line footnote to its first `undeclared`. None of them says what is wrong with
+ *  the statement, and a `previous declaration` line points into the context rather than at the
+ *  candidate. */
+const CONTINUATION =
+  /^(?:previous (?:implicit )?(?:declaration|definition)\b|this is the location of\b|\(Each undeclared identifier\b|for each function it appears in\b|.*\bpreviously (?:declared|defined) here$)/i;
+/** A position spelled INSIDE a message rather than ahead of it: IDO's `redeclaration of 'a';
+ *  previous declaration at line 2 in file '/tmp/x/cand.c'`, whose file is a scratch directory that
+ *  differs per compile. */
+const POSITION_IN_MESSAGE = /\s*\bat line \d+ in file '[^']*'/g;
+
+/** The compiler's ERROR lines, each reduced to its message: no file, no line, no column, no
+ *  `error:` tag. Warnings, notes, `In function` banners, `previous declaration` lines and source
+ *  excerpts are not errors and are not here. Empty when the text holds nothing this recognises —
+ *  which is an answer the caller must treat as "unknown", never as "no errors". */
+export function errorMessages(diagnostic: string): string[] {
+  const lines = diagnostic
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+  const out: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const caret = MWCC_CARET.exec(lines[i]);
+    if (caret !== null) {
+      const parts: string[] = [];
+      while (i + 1 < lines.length && MWCC_MESSAGE.test(lines[i + 1])) {
+        parts.push(lines[++i].replace(/^#\s*/, ''));
+      }
+      if (caret[1].toLowerCase() === 'error' && parts.length > 0) {
+        out.push(parts.join(' '));
+      }
+      continue;
+    }
+    if (isAdvisory(lines[i])) {
+      continue;
+    }
+    const located = LOCATED.exec(lines[i]);
+    const message = located === null ? TAGGED.exec(lines[i])?.[1] : located[1].replace(ERROR_TAG, '');
+    if (message !== undefined && message !== '' && !CONTINUATION.test(message)) {
+      out.push(message.replace(POSITION_IN_MESSAGE, ''));
+    }
+  }
+  return out;
+}
+
+/** A compiler that STOPPED REPORTING before it was done: IDO after 30 errors, clang at its
+ *  `-ferror-limit`, gcc under `-fmax-errors` or `-Wfatal-errors`, mwcc under `-maxerrors`. What it
+ *  printed is a prefix of its verdict, and two prefixes equal each other whatever follows them.
+ *  clang under `-Wfatal-errors` prints no trailer at all, so the flag side (codegen-flags.ts
+ *  `limitsErrors`) is what keeps that one out of a ranked compile. */
+const TRUNCATED =
+  /Too many errors\.\.\. goodbye|too many errors emitted|compilation terminated due to -(?:fmax-errors|Wfatal-errors)|^User break, cancelled/im;
+
+/** The error messages of a diagnostic that can be READ AS A VERDICT: `errorMessages`, or null when
+ *  it recognises none, and null when the compiler stopped reporting — what an unfinished
+ *  diagnostic printed is a prefix of its verdict, and two prefixes agree whatever follows them. */
+export function verdictMessages(diagnostic: string): string[] | null {
+  if (TRUNCATED.test(diagnostic)) {
+    return null;
+  }
+  const messages = errorMessages(diagnostic);
+  return messages.length === 0 ? null : messages;
+}
+
+/** One compile ATTEMPT inside a diagnostic that holds several: what the harness called the
+ *  attempt, and what the compiler printed for it. */
+export interface Attempt {
+  label: string;
+  diagnostic: string;
+}
+
+/** The line that opens an attempt. Owned here because it is read here: a harness that spelled its
+ *  own could not be split back, and every one of its rejections would read as a single attempt. */
+const ATTEMPT_HEADER = /^--- (.+) ---$/;
+
+/** ONE REJECTION, SEVERAL COMPILES. A harness that tries a candidate in more than one world before
+ *  it gives up — the benchmark's real tier climbs a ladder of contexts, in two dialects — throws one
+ *  rejection for all of them, and whoever compares two rejections has to ask what EACH attempt
+ *  said: a world no candidate can compile in prints the same sentence for every candidate, and read
+ *  as one text that sentence would say the whole fan fails alike. So the attempts travel under a
+ *  header line per attempt, in the order they were tried, and `attemptsOf` splits them back.
+ *
+ *  The header is no error line to `errorMessages`, so the joined text reads as the whole of what
+ *  every attempt printed, which is what a store of rejections keeps and a printer prints. A label
+ *  holds no line break; a compiler line that happens to read as a header would split its attempt
+ *  in two, alike in every candidate that printed it. */
+export function joinAttempts(attempts: readonly Attempt[]): string {
+  return attempts.map((a) => `--- ${a.label} ---\n${a.diagnostic}`).join('\n');
+}
+
+/** The attempts `joinAttempts` joined, in order. A diagnostic with no header is ONE attempt,
+ *  labelled `''`: a single compile is the ordinary case, not a degenerate one. Text ahead of the
+ *  first header is an attempt of its own when it holds anything, because dropping it would drop
+ *  what it said. */
+export function attemptsOf(diagnostic: string): Attempt[] {
+  const out: Attempt[] = [];
+  let label: string | null = null;
+  let lines: string[] = [];
+  const close = () => {
+    if (label !== null || lines.some((l) => l.trim() !== '')) {
+      out.push({ label: label ?? '', diagnostic: lines.join('\n') });
+    }
+  };
+  for (const line of diagnostic.split('\n')) {
+    const header = ATTEMPT_HEADER.exec(line);
+    if (header === null) {
+      lines.push(line);
+      continue;
+    }
+    close();
+    label = header[1];
+    lines = [];
+  }
+  close();
+  return out.length > 0 ? out : [{ label: '', diagnostic }];
+}