Operators Fix

src/modules/loader/requireProvider.ts

@@ -7,6 +7,7 @@ import type { Context, Node } from '../../types';
 import * as types from '../../types';
 import * as assert from '../../utils/assert';
 import * as stringify from '../../utils/stringify';
+import * as operators from '../../utils/operators';
 import * as errorBase from '../../errors/base';
 import * as rttcErrors from '../../errors/rttcErrors';
 import * as rttc from '../../utils/rttc';
@@ -39,8 +40,9 @@ export function getRequireProvider(context: Context) {
         types,
         utils: {
           assert,
-          stringify,
+          operators,
           rttc,
+          stringify,
         },
       },
       context,

src/name-extractor/__tests__/modules.test.ts

@@ -171,6 +171,7 @@ describe('test name extractor functionality on imports', () => {
   const mockImportDecl: ImportDeclaration = {
     type: 'ImportDeclaration',
     specifiers: [],
+    attributes: [],
     source: {
       type: 'Literal',
       value: 'nothing',

src/utils/__tests__/misc.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
-import { Chapter } from '../../langs';
-import { getChapterName, PromiseTimeoutError, timeoutPromise } from '../misc';
+import { Chapter, Variant } from '../../langs';
+import { getChapterName, getVariantName, PromiseTimeoutError, timeoutPromise } from '../misc';
 
 describe(timeoutPromise, () => {
   const timedResolvedPromise = (duration: number) =>
@@ -38,3 +38,13 @@ describe(getChapterName, () =>
     ['FULL_JS', Chapter.FULL_JS],
   ])('%s', (expected, input) => expect(getChapterName(input)).toEqual(expected)),
 );
+
+describe(getVariantName, () => {
+  test.each([
+    ['DEFAULT', Variant.DEFAULT],
+    ['TYPED', Variant.TYPED],
+    ['NATIVE', Variant.NATIVE],
+    ['WASM', Variant.WASM],
+    ['EXPLICIT_CONTROL', Variant.EXPLICIT_CONTROL],
+  ])('%s', (expected, input) => expect(getVariantName(input)).toEqual(expected));
+});

src/utils/__tests__/rttc.test.ts

@@ -30,6 +30,19 @@ describe('rttc Type Guards', () => {
       expect(rttc.typeOf(obj)).toEqual('object');
     });
   });
+
+  test('TypeofConstantsToType', () => {
+    expectTypeOf<rttc.TypeOfConstantToType<'array'>>().toEqualTypeOf<unknown[]>();
+    expectTypeOf<rttc.TypeOfConstantToType<'bigint'>>().toEqualTypeOf<bigint>();
+    expectTypeOf<rttc.TypeOfConstantToType<'boolean'>>().toEqualTypeOf<boolean>();
+    expectTypeOf<rttc.TypeOfConstantToType<'function'>>().toEqualTypeOf<(...args: any[]) => any>();
+    expectTypeOf<rttc.TypeOfConstantToType<'regexp'>>().toEqualTypeOf<RegExp>();
+    expectTypeOf<rttc.TypeOfConstantToType<'null'>>().toEqualTypeOf<null>();
+    expectTypeOf<rttc.TypeOfConstantToType<'number'>>().toEqualTypeOf<number>();
+    expectTypeOf<rttc.TypeOfConstantToType<'object'>>().toEqualTypeOf<object>();
+    expectTypeOf<rttc.TypeOfConstantToType<'string'>>().toEqualTypeOf<string>();
+    expectTypeOf<rttc.TypeOfConstantToType<'undefined'>>().toEqualTypeOf<undefined>();
+  })
 });
 
 interface Fixtures {
@@ -422,6 +435,24 @@ describe(rttc.isTupleOfLength, () => {
     const tup: unknown = [0, 0];
     expect(rttc.isTupleOfLength(tup, 1)).toEqual(false);
   });
+
+  test('with predicate type guard', () => {
+    const tup: unknown = [0, 0];
+    if (rttc.isTupleOfLength(tup, 2, x => typeof x === 'number')) {
+      expectTypeOf(tup).toEqualTypeOf<[number, number]>();
+    } else {
+      expect.fail();
+    }
+  });
+
+  test('with string type guard', () => {
+    const tup: unknown = [0, 0];
+    if (rttc.isTupleOfLength(tup, 2, 'number')) {
+      expectTypeOf(tup).toEqualTypeOf<[number, number]>();
+    } else {
+      expect.fail();
+    }
+  });
 });
 
 describe(rttc.isNumberWithinRange, () => {

src/utils/misc.ts

@@ -42,11 +42,14 @@ export function objectKeys<T extends string | number | symbol>(obj: Record<T, an
   return Object.keys(obj) as T[];
 }
 
+type EnumKeys<T> = T extends Record<infer K, any> ? K : never;
+type ChapterStrings = EnumKeys<typeof Chapter>;
+
 /**
  * Given the chapter value, return the string name of that chapter
  */
 export function getChapterName(chapter: Chapter) {
-  return objectKeys(Chapter).find(name => Chapter[name] === chapter)!;
+  return Chapter[chapter] as ChapterStrings;
 }
 
 /**

src/utils/operators.ts

@@ -240,6 +240,17 @@ export function callIfFuncAndRightArgs(
   }
 }
 
+/**
+ * Convenience wrapper for {@link callIfFuncAndRightArgs} that doesn't require any
+ * extra metadata to be passed into the function.
+ */
+export function callWithoutMetadata<T extends (...args: any[]) => any>(
+  f: T,
+  ...args: Parameters<T>
+): ReturnType<T> {
+  return callIfFuncAndRightArgs(f, -1, -1, null, undefined, ...args);
+}
+
 /**
  * Augment the given function with the necessary information for it to be called
  * properly by {@link callIfFuncAndRightArgs}. It won't redefine any existing details

src/utils/rttc.ts

@@ -37,21 +37,43 @@ export class RuntimeTypeError extends RuntimeSourceError<Node> {
 
 type TypeOfConstants =
   | 'array'
-  | 'boolean'
   | 'bigint'
+  | 'boolean'
   | 'function'
-  | 'number'
   | 'null'
+  | 'number'
   | 'object'
   | 'regexp'
   | 'string'
   | 'undefined';
 
+export type TypeOfConstantToType<T extends TypeOfConstants> = T extends 'array'
+  ? unknown[]
+  : T extends 'bigint'
+    ? bigint
+    : T extends 'boolean'
+      ? boolean
+      : T extends 'function'
+        ? (...args: any[]) => any
+        : T extends 'null'
+          ? null
+          : T extends 'number'
+            ? number
+            : T extends 'object'
+              ? object
+              : T extends 'regexp'
+                ? RegExp
+                : T extends 'string'
+                  ? string
+                  : T extends 'undefined'
+                    ? undefined
+                    : never;
+
 /**
  * A wrapper around the typeof operator to account for `null` and arrays.
  */
-export function typeOf(v: boolean): 'boolean';
 export function typeOf(v: bigint): 'bigint';
+export function typeOf(v: boolean): 'boolean';
 export function typeOf(v: number): 'number';
 export function typeOf(v: RegExp): 'regexp';
 export function typeOf(v: string): 'string';
@@ -344,13 +366,33 @@ export function assertFunctionOfLength(
 }
 
 /**
- * Function for checking if the given `obj` is a tuple of the given length.
+ * Function for checking if the given `obj` is a tuple of the given length. Optionally, providing a type guard
+ * function or string can type check the entire tuple.
  */
 export function isTupleOfLength<T extends number, U>(obj: U[], l: T): obj is TupleOfLength<T, U>;
+export function isTupleOfLength<T extends number, U>(
+  obj: unknown,
+  l: T,
+  guard: (arg: unknown) => arg is U,
+): obj is TupleOfLength<T, U>;
+export function isTupleOfLength<T extends number, U extends TypeOfConstants>(
+  obj: unknown,
+  l: T,
+  guard: U,
+): obj is TupleOfLength<T, TypeOfConstantToType<U>>;
 export function isTupleOfLength<T extends number>(obj: unknown, l: T): obj is TupleOfLength<T>;
-export function isTupleOfLength<T extends number>(obj: unknown, l: T): obj is TupleOfLength<T> {
+export function isTupleOfLength<T extends number>(
+  obj: unknown,
+  l: T,
+  guard?: ((arg: unknown) => boolean) | TypeOfConstants,
+): boolean {
   if (!Array.isArray(obj)) return false;
-  return obj.length === l;
+  if (obj.length !== l) return false;
+
+  if (typeof guard === 'string') return obj.every(each => typeOf(each) === guard);
+  else if (guard !== undefined) return obj.every(guard);
+
+  return true;
 }
 
 /**

src/utils/stringify.ts

@@ -2,7 +2,7 @@ import { MAX_LIST_DISPLAY_LENGTH } from '../constants';
 import Closure from '../cse-machine/closure';
 import { InternalRuntimeError } from '../errors/base';
 import type { Type, Value } from '../types';
-import { callIfFuncAndRightArgs } from './operators';
+import { callWithoutMetadata } from './operators';
 
 export interface ArrayLike {
   replPrefix: string;
@@ -437,7 +437,7 @@ export function valueToStringDag(value: Value): StringDag {
       // callIfFuncAndRight args is necessary because if we implement toReplString as a function
       // in Source, it gets wrapped by the transpiler
       // this allows object literals to implement toReplString
-      const reprValue = callIfFuncAndRightArgs(v.toReplString.bind(v), -1, -1, null, undefined);
+      const reprValue = callWithoutMetadata(v.toReplString.bind(v));
       return convertRepr(reprValue);
     } else if (typeof v !== 'object') {
       return convertRepr(v.toString());

src/utils/testing/mocks.ts

@@ -26,6 +26,7 @@ export function mockImportDeclaration(): es.ImportDeclaration {
         },
       },
     ],
+    attributes: [],
     source: {
       type: 'Literal',
       value: 'mock-path',