@asmlift/core 0.9.0 → 0.11.0

package/src/variation-tokens.ts

@@ -67,8 +67,13 @@ const TOKENS = [
   // lift: the assembly lifted or raised again
   { name: 'setup-args', variationKind: 'lift' },
   { name: 'connective', variationKind: 'lift' },
+  { name: 'narrow-param', variationKind: 'lift' },
   { name: 'shared-ret', variationKind: 'lift' },
+  { name: 'ret-copy', variationKind: 'lift' },
+  { name: 'ret-join', variationKind: 'lift' },
   { name: 'shared-tail', variationKind: 'lift' },
+  { name: 'kept-slot', variationKind: 'lift' },
+  { name: 'far-cast', variationKind: 'lift' },
   // structure: `structure()` re-run with other options
   { name: 'flip-branch', variationKind: 'structure' },
   { name: 'defsite', variationKind: 'structure' },
@@ -86,12 +91,16 @@ const TOKENS = [
   { name: 'derived-home', variationKind: 'structure' },
   { name: 'merge-home', variationKind: 'structure' },
   { name: 'escape-home', variationKind: 'structure' },
-  { name: 'uns-cmp', variationKind: 'structure' },
+  { name: 'signed-cmp', variationKind: 'structure' },
   { name: 'fresh-merge', variationKind: 'structure' },
   { name: 'copy-defpos', variationKind: 'structure' },
   { name: 'site-sense', variationKind: 'structure' },
+  { name: 'tail-copies', variationKind: 'structure' },
+  { name: 'for-continue', variationKind: 'structure' },
+  { name: 'case-goto', variationKind: 'structure' },
   // respell: the structured tree rewritten
   { name: 'unmerge', variationKind: 'respell' },
+  { name: 'case-end-goto', variationKind: 'respell' },
   { name: 'argbase', variationKind: 'respell' },
   { name: 'zerosub', variationKind: 'respell' },
   { name: 'volatile', variationKind: 'respell', subject: LOCALS },
@@ -131,6 +140,7 @@ const TOKENS = [
   { name: 'pollguard', variationKind: 'respell' },
   { name: 'pollread', variationKind: 'respell' },
   { name: 'narrow-decl', variationKind: 'respell' },
+  { name: 'narrow-load', variationKind: 'respell' },
   { name: 'narrow-read', variationKind: 'respell' },
   {
     name: 'int-cell',
@@ -289,6 +299,40 @@ export function splitVariations(name: string): string[] {
   return variations;
 }
 
+/** What is wrong with one candidate's name, or `undefined`: no variation at all, a variation the
+ *  registry does not hold, a first variation that is not a signedness, or a variation after one of
+ *  a later kind. The mint sites are typed, so none of these is a `tsc` error; enumeration data is
+ *  the only place one shows, and `tallyFanVariations` asks this of every candidate it counts. */
+export function variationsDefect(variations: readonly string[]): string | undefined {
+  try {
+    return orderDefect(variations, (part) => kindIndex(parseVariation(part).name));
+  } catch (e) {
+    return `${variations.join('/')}: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+const kindIndex = (name: string): number => VARIATION_KINDS.indexOf(variationToken(name).variationKind);
+
+/** `variationsDefect` past the registry lookup, which `kindOf` does (and throws from) so the tally
+ *  can serve it from its own cache. */
+function orderDefect(variations: readonly string[], kindOf: (part: string) => number): string | undefined {
+  if (variations.length === 0) {
+    return 'a candidate with no variations: it applies at least its signedness';
+  }
+  let previous = -1;
+  for (const [i, part] of variations.entries()) {
+    const kind = kindOf(part);
+    if (i === 0 && VARIATION_KINDS[kind] !== 'signedness') {
+      return `${variations.join('/')}: the first variation is '${part}', not a signedness`;
+    }
+    if (kind < previous) {
+      return `${variations.join('/')}: '${part}' (${VARIATION_KINDS[kind]}) after a ${VARIATION_KINDS[previous]} variation`;
+    }
+    previous = kind;
+  }
+  return undefined;
+}
+
 /** How many of one fan's candidates carry one variation. `candidates` counts the whole fan —
  *  scored, dropped, withheld and never compiled alike — and `dropped`, `withheld` and
  *  `notCompiled` are the parts of that count the ranking did not score, each absent when 0.
@@ -315,7 +359,15 @@ interface NamedCandidate {
  *
  *  A tally, not a factorisation: enumeration gates prune the fan, so the counts do not multiply to
  *  its size. Keys run in kind order, then by name, so two tallies of one fan serialize to the same
- *  bytes whatever order the fan was listed in. Throws on a variation the registry does not hold. */
+ *  bytes whatever order the fan was listed in.
+ *
+ *  Throws on any candidate whose name `variationsDefect` refuses — an unregistered variation, a
+ *  first variation that is not a signedness, parts out of kind order. The bench tallies every fan
+ *  it ranks to a verdict or refuses whole, every candidate of it, on both tiers, so this is where a
+ *  malformed mint is caught: the artifact keeps only the winner's and the refused candidates' names,
+ *  and a test that re-enumerated the synthetic tier to read the rest cost minutes and never saw the
+ *  real one. A rank a scorer dies in leaves a `noncompile` row with no fan, so nothing is tallied
+ *  there. */
 export function tallyFanVariations(fan: {
   candidates: readonly NamedCandidate[];
   dropped: readonly NamedCandidate[];
@@ -331,9 +383,23 @@ export function tallyFanVariations(fan: {
     }
     return name;
   };
+  const kindOfName = new Map<string, number>();
+  const kindOf = (part: string): number => {
+    const name = nameOf(part);
+    let kind = kindOfName.get(name);
+    if (kind === undefined) {
+      kind = kindIndex(name);
+      kindOfName.set(name, kind);
+    }
+    return kind;
+  };
   const counts = new Map<string, { candidates: number; dropped: number; withheld: number; notCompiled: number }>();
   const add = (list: readonly NamedCandidate[], refusal: 'dropped' | 'withheld' | 'notCompiled' | undefined): void => {
     for (const c of list) {
+      const defect = orderDefect(c.variations, kindOf);
+      if (defect !== undefined) {
+        throw new Error(`a fan candidate's name is malformed — ${defect} (packages/core/src/variation-tokens.ts)`);
+      }
       for (const name of new Set(c.variations.map(nameOf))) {
         let n = counts.get(name);
         if (n === undefined) {
@@ -351,7 +417,6 @@ export function tallyFanVariations(fan: {
   add(fan.dropped, 'dropped');
   add(fan.withheld, 'withheld');
   add(fan.notCompiled, 'notCompiled');
-  const kindIndex = (name: string): number => VARIATION_KINDS.indexOf(variationToken(name).variationKind);
   const names = [...counts.keys()].sort((a, b) => kindIndex(a) - kindIndex(b) || (a < b ? -1 : a > b ? 1 : 0));
   return Object.fromEntries(
     names.map((name) => {