typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/RandomProgrammer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
@@ -11,6 +11,9 @@ import { TypeFactory } from "../factories/TypeFactory";
 import { ICommentTag } from "../metadata/ICommentTag";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataArray } from "../metadata/MetadataArray";
+import { MetadataObject } from "../metadata/MetadataObject";
+import { MetadataTuple } from "../metadata/MetadataTuple";
 
 import { IProject } from "../transformers/IProject";
 
@@ -20,55 +23,75 @@ import { RandomRanger } from "./helpers/RandomRanger";
 import { random_custom } from "./internal/random_custom";
 
 export namespace RandomProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            init?: ts.Expression,
+        ) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(init)(type, name);
+
     export const write =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (init?: ts.Expression) => {
-            const tsc: typeof ts = p.tsc;
-            const importer: FunctionImporter = new FunctionImporter(tsc);
-
+            const importer: FunctionImporter = new FunctionImporter();
             return (type: ts.Type, name?: string) => {
                 // INITIALIZE METADATA
                 const collection: MetadataCollection = new MetadataCollection();
-                const meta: Metadata = MetadataFactory.analyze(p)({
-                    resolve: true,
-                    constant: true,
-                })(collection)(type);
+                const meta: Metadata = MetadataFactory.analyze(project.checker)(
+                    {
+                        resolve: true,
+                        constant: true,
+                        absorb: true,
+                    },
+                )(collection)(type);
 
                 // GENERATE FUNCTION
-                const functors: ts.VariableStatement[] =
-                    generate_functors(tsc)(importer)(collection);
-                const output: ts.Expression = decode(tsc)(importer)({
-                    object: false,
+                const functions = {
+                    objects: write_object_functions(importer)(collection),
+                    arrays: write_array_functions(importer)(collection),
+                    tuples: write_tuple_functions(importer)(collection),
+                };
+
+                const output: ts.Expression = decode(importer)({
+                    function: false,
                     recursive: false,
                 })(meta, [], []);
 
-                return tsc.factory.createArrowFunction(
+                return ts.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [
-                        IdentifierFactory.parameter(tsc)(
+                        IdentifierFactory.parameter(
                             "generator",
-                            tsc.factory.createTypeReferenceNode(
+                            ts.factory.createTypeReferenceNode(
                                 "Partial<typia.IRandomGenerator>",
                             ),
                             init ??
-                                tsc.factory.createToken(
-                                    tsc.SyntaxKind.QuestionToken,
+                                ts.factory.createToken(
+                                    ts.SyntaxKind.QuestionToken,
                                 ),
                         ),
                     ],
-                    tsc.factory.createTypeReferenceNode(
+                    ts.factory.createTypeReferenceNode(
                         `typia.Primitive<${
-                            name ?? TypeFactory.getFullName(p)(type)
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
                         }>`,
                     ),
                     undefined,
-                    tsc.factory.createBlock(
+                    ts.factory.createBlock(
                         [
                             ...importer.declare(modulo),
-                            ...functors,
-                            tsc.factory.createReturnStatement(output),
+                            ...functions.objects,
+                            ...functions.arrays,
+                            ...functions.tuples,
+                            ts.factory.createReturnStatement(output),
                         ],
                         true,
                     ),
@@ -76,47 +99,128 @@ export namespace RandomProgrammer {
             };
         };
 
-    const generate_functors =
-        (tsc: typeof ts) =>
+    const write_object_functions =
         (importer: FunctionImporter) =>
-        (collection: MetadataCollection) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
             collection.objects().map((obj, i) =>
-                StatementFactory.constant(tsc)(
-                    FUNCTOR(i),
-                    tsc.factory.createArrowFunction(
+                StatementFactory.constant(
+                    PREFIX.object(i),
+                    ts.factory.createArrowFunction(
                         undefined,
                         undefined,
                         [
-                            IdentifierFactory.parameter(tsc)(
+                            IdentifierFactory.parameter(
                                 "_recursive",
-                                TypeFactory.keyword(tsc)("boolean"),
-                                tsc.factory.createIdentifier(
+                                TypeFactory.keyword("boolean"),
+                                ts.factory.createIdentifier(
                                     String(obj.recursive),
                                 ),
                             ),
-                            IdentifierFactory.parameter(tsc)(
+                            IdentifierFactory.parameter(
                                 "_depth",
-                                TypeFactory.keyword(tsc)("number"),
-                                tsc.factory.createNumericLiteral(0),
+                                TypeFactory.keyword("number"),
+                                ts.factory.createNumericLiteral(0),
                             ),
                         ],
-                        TypeFactory.keyword(tsc)("any"),
+                        TypeFactory.keyword("any"),
                         undefined,
-                        RandomJoiner.object(tsc)(COALESCE(tsc)(importer))(
-                            decode(tsc)(importer)({
+                        RandomJoiner.object(COALESCE(importer))(
+                            decode(importer)({
                                 recursive: obj.recursive,
-                                object: true,
+                                function: true,
                             }),
                         )(obj),
                     ),
                 ),
             );
 
+    const write_array_functions =
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .arrays()
+                .filter((a) => a.recursive)
+                .map((array, i) =>
+                    StatementFactory.constant(
+                        PREFIX.array(i),
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [
+                                IdentifierFactory.parameter(
+                                    "length",
+                                    TypeFactory.keyword("number"),
+                                ),
+                                IdentifierFactory.parameter(
+                                    "_recursive",
+                                    TypeFactory.keyword("boolean"),
+                                    ts.factory.createTrue(),
+                                ),
+                                IdentifierFactory.parameter(
+                                    "_depth",
+                                    TypeFactory.keyword("number"),
+                                    ts.factory.createNumericLiteral(0),
+                                ),
+                            ],
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            RandomJoiner.array(COALESCE(importer))(
+                                decode(importer)({
+                                    recursive: true,
+                                    function: true,
+                                }),
+                            )({
+                                recursive: true,
+                                function: true,
+                            })(ts.factory.createIdentifier("length"))(
+                                array.value,
+                                [],
+                                [],
+                            ),
+                        ),
+                    ),
+                );
+
+    const write_tuple_functions =
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .tuples()
+                .filter((a) => a.recursive)
+                .map((tuple, i) =>
+                    StatementFactory.constant(
+                        PREFIX.tuple(i),
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [
+                                IdentifierFactory.parameter(
+                                    "_recursive",
+                                    TypeFactory.keyword("boolean"),
+                                    ts.factory.createTrue(),
+                                ),
+                                IdentifierFactory.parameter(
+                                    "_depth",
+                                    TypeFactory.keyword("number"),
+                                    ts.factory.createNumericLiteral(0),
+                                ),
+                            ],
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            RandomJoiner.tuple(
+                                decode(importer)({
+                                    function: true,
+                                    recursive: true,
+                                }),
+                            )(tuple.elements, [], []),
+                        ),
+                    ),
+                );
+
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     const decode =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (explore: IExplore) =>
         (
@@ -127,137 +231,71 @@ export namespace RandomProgrammer {
             const expressions: ts.Expression[] = [];
             if (meta.any)
                 expressions.push(
-                    tsc.factory.createStringLiteral(
+                    ts.factory.createStringLiteral(
                         "fucking any type exists...",
                     ),
                 );
 
             // NULL COALESCING
             if (meta.required === false)
-                expressions.push(tsc.factory.createIdentifier("undefined"));
+                expressions.push(ts.factory.createIdentifier("undefined"));
             if (meta.nullable === true)
-                expressions.push(tsc.factory.createNull());
+                expressions.push(ts.factory.createNull());
 
             // CONSTANT TYPES
             for (const constant of meta.constants)
                 for (const value of constant.values)
-                    expressions.push(decode_atomic(tsc)(value));
+                    expressions.push(decode_atomic(value));
 
             // ATOMIC VARIABLES
             for (const template of meta.templates)
-                expressions.push(
-                    decode_template(tsc)(importer)(explore)(template),
-                );
+                expressions.push(decode_template(importer)(explore)(template));
             for (const atomic of meta.atomics)
                 if (atomic === "boolean")
-                    expressions.push(decode_boolean(tsc)(importer));
+                    expressions.push(decode_boolean(importer));
                 else if (atomic === "number")
-                    expressions.push(
-                        decode_number(tsc)(importer)(tags)(comments),
-                    );
+                    expressions.push(decode_number(importer)(tags)(comments));
                 else if (atomic === "string")
-                    expressions.push(
-                        decode_string(tsc)(importer)(tags)(comments),
-                    );
+                    expressions.push(decode_string(importer)(tags)(comments));
                 else if (atomic === "bigint")
-                    expressions.push(
-                        decode_bigint(tsc)(importer)(tags)(comments),
-                    );
+                    expressions.push(decode_bigint(importer)(tags)(comments));
 
             // INSTANCE TYPES
             if (meta.resolved)
                 expressions.push(
-                    decode(tsc)(importer)(explore)(
-                        meta.resolved,
-                        tags,
-                        comments,
-                    ),
+                    decode(importer)(explore)(meta.resolved, tags, comments),
                 );
-            for (const t of meta.tuples)
+            for (const array of meta.arrays)
                 expressions.push(
-                    RandomJoiner.tuple(tsc)(decode(tsc)(importer)(explore))(
-                        t,
-                        tags,
-                        comments,
-                    ),
+                    decode_array(importer)(explore)(array, tags, comments),
                 );
-            for (const a of meta.arrays) {
-                const array = RandomJoiner.array(tsc)(COALESCE(tsc)(importer))(
-                    decode(tsc)(importer)(explore),
-                )(a, tags, comments);
+            for (const tuple of meta.tuples)
                 expressions.push(
-                    explore.recursive && a.objects.length
-                        ? tsc.factory.createConditionalExpression(
-                              tsc.factory.createLogicalAnd(
-                                  tsc.factory.createIdentifier("_recursive"),
-                                  tsc.factory.createLessThan(
-                                      tsc.factory.createNumericLiteral(5),
-                                      tsc.factory.createIdentifier("_depth"),
-                                  ),
-                              ),
-                              undefined,
-                              tsc.factory.createIdentifier("[]"),
-                              undefined,
-                              array,
-                          )
-                        : array,
+                    decode_tuple(importer)(explore)(tuple, tags, comments),
                 );
-            }
             for (const o of meta.objects)
-                expressions.push(
-                    tsc.factory.createCallExpression(
-                        tsc.factory.createIdentifier(FUNCTOR(o.index)),
-                        undefined,
-                        explore.object
-                            ? [
-                                  explore.recursive
-                                      ? tsc.factory.createTrue()
-                                      : tsc.factory.createIdentifier(
-                                            "_recursive",
-                                        ),
-                                  tsc.factory.createConditionalExpression(
-                                      tsc.factory.createIdentifier(
-                                          "_recursive",
-                                      ),
-                                      undefined,
-                                      tsc.factory.createAdd(
-                                          tsc.factory.createNumericLiteral(1),
-                                          tsc.factory.createIdentifier(
-                                              "_depth",
-                                          ),
-                                      ),
-                                      undefined,
-                                      tsc.factory.createIdentifier("_depth"),
-                                  ),
-                              ]
-                            : undefined,
-                    ),
-                );
+                expressions.push(decode_object(importer)(explore)(o));
             for (const native of meta.natives)
                 if (native === "Boolean")
-                    expressions.push(decode_boolean(tsc)(importer));
+                    expressions.push(decode_boolean(importer));
                 else if (native === "Number")
-                    expressions.push(
-                        decode_number(tsc)(importer)(tags)(comments),
-                    );
+                    expressions.push(decode_number(importer)(tags)(comments));
                 else if (native === "String")
-                    expressions.push(
-                        decode_string(tsc)(importer)(tags)(comments),
-                    );
-                else expressions.push(tsc.factory.createIdentifier("{}"));
+                    expressions.push(decode_string(importer)(tags)(comments));
+                else expressions.push(ts.factory.createIdentifier("{}"));
             if (meta.sets.length || meta.maps.length)
-                expressions.push(tsc.factory.createIdentifier("{}"));
+                expressions.push(ts.factory.createIdentifier("{}"));
 
             // PRIMITIVE TYPES
             if (expressions.length === 1) return expressions[0]!;
-            return tsc.factory.createCallExpression(
-                tsc.factory.createCallExpression(
+            return ts.factory.createCallExpression(
+                ts.factory.createCallExpression(
                     importer.use("pick"),
                     undefined,
                     [
-                        tsc.factory.createArrayLiteralExpression(
+                        ts.factory.createArrayLiteralExpression(
                             expressions.map((expr) =>
-                                tsc.factory.createArrowFunction(
+                                ts.factory.createArrowFunction(
                                     undefined,
                                     undefined,
                                     [],
@@ -275,35 +313,31 @@ export namespace RandomProgrammer {
             );
         };
 
-    const decode_boolean = (tsc: typeof ts) => (importer: FunctionImporter) =>
-        tsc.factory.createCallExpression(
-            COALESCE(tsc)(importer)("boolean"),
+    const decode_boolean = (importer: FunctionImporter) =>
+        ts.factory.createCallExpression(
+            COALESCE(importer)("boolean"),
             undefined,
             undefined,
         );
 
-    const decode_atomic = (tsc: typeof ts) => (value: Atomic) =>
+    const decode_atomic = (value: Atomic) =>
         typeof value === "boolean"
-            ? tsc.factory.createIdentifier(value.toString())
+            ? ts.factory.createIdentifier(value.toString())
             : typeof value === "number"
-            ? tsc.factory.createNumericLiteral(value)
+            ? ts.factory.createNumericLiteral(value)
             : typeof value === "string"
-            ? tsc.factory.createStringLiteral(value)
-            : tsc.factory.createBigIntLiteral(value.toString());
+            ? ts.factory.createStringLiteral(value)
+            : ts.factory.createBigIntLiteral(value.toString());
 
     const decode_template =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (explore: IExplore) =>
         (template: Metadata[]) =>
-            TemplateFactory.generate(tsc)(
-                template.map((meta) =>
-                    decode(tsc)(importer)(explore)(meta, [], []),
-                ),
+            TemplateFactory.generate(
+                template.map((meta) => decode(importer)(explore)(meta, [], [])),
             );
 
     const decode_number =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (tags: IMetadataTag[]) =>
         (comments: ICommentTag[]): ts.Expression => {
@@ -314,26 +348,24 @@ export namespace RandomProgrammer {
                 : tags.find((t) => t.kind === "type" && t.value === "int")
                 ? "uint"
                 : "double";
-            return random_custom(tsc)(COALESCE(tsc)(importer))("number")(
-                comments,
-            )(
-                RandomRanger.number(tsc)({
+            return random_custom(COALESCE(importer))("number")(comments)(
+                RandomRanger.number({
                     type,
                     transform: (value) =>
-                        tsc.factory.createNumericLiteral(value),
+                        ts.factory.createNumericLiteral(value),
                     setter: (args) =>
-                        tsc.factory.createCallExpression(
+                        ts.factory.createCallExpression(
                             type === "double" &&
                                 tags.every(
                                     (t) =>
                                         t.kind !== "multipleOf" &&
                                         t.kind !== "step",
                                 )
-                                ? COALESCE(tsc)(importer)("number")
-                                : COALESCE(tsc)(importer)("integer"),
+                                ? COALESCE(importer)("number")
+                                : COALESCE(importer)("integer"),
                             undefined,
                             args.map((val) =>
-                                tsc.factory.createNumericLiteral(val),
+                                ts.factory.createNumericLiteral(val),
                             ),
                         ),
                 })({
@@ -345,33 +377,32 @@ export namespace RandomProgrammer {
         };
 
     const decode_bigint =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (tags: IMetadataTag[]) =>
         (comments: ICommentTag[]): ts.Expression =>
-            random_custom(tsc)(COALESCE(tsc)(importer))("bigint")(comments)(
-                RandomRanger.number(tsc)({
+            random_custom(COALESCE(importer))("bigint")(comments)(
+                RandomRanger.number({
                     type: tags.find(
                         (t) => t.kind === "type" && t.value === "uint",
                     )
                         ? "uint"
                         : "int",
                     transform: (value) =>
-                        tsc.factory.createCallExpression(
-                            tsc.factory.createIdentifier("BigInt"),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("BigInt"),
                             undefined,
-                            [tsc.factory.createStringLiteral(value.toString())],
+                            [ts.factory.createStringLiteral(value.toString())],
                         ),
                     setter: (args) =>
-                        tsc.factory.createCallExpression(
-                            COALESCE(tsc)(importer)("bigint"),
+                        ts.factory.createCallExpression(
+                            COALESCE(importer)("bigint"),
                             undefined,
                             args.map((value) =>
-                                tsc.factory.createCallExpression(
-                                    tsc.factory.createIdentifier("BigInt"),
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("BigInt"),
                                     undefined,
                                     [
-                                        tsc.factory.createStringLiteral(
+                                        ts.factory.createStringLiteral(
                                             value.toString(),
                                         ),
                                     ],
@@ -386,29 +417,26 @@ export namespace RandomProgrammer {
             );
 
     const decode_string =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (tags: IMetadataTag[]) =>
         (comments: ICommentTag[]): ts.Expression =>
-            random_custom(tsc)(COALESCE(tsc)(importer))("string")(comments)(
+            random_custom(COALESCE(importer))("string")(comments)(
                 (() => {
                     for (const t of tags)
                         if (t.kind === "format")
-                            return tsc.factory.createCallExpression(
-                                COALESCE(tsc)(importer)(t.value),
+                            return ts.factory.createCallExpression(
+                                COALESCE(importer)(t.value),
                                 undefined,
                                 undefined,
                             );
                         else if (t.kind === "pattern")
-                            return tsc.factory.createCallExpression(
-                                COALESCE(tsc)(importer)("pattern"),
+                            return ts.factory.createCallExpression(
+                                COALESCE(importer)("pattern"),
                                 undefined,
-                                [tsc.factory.createIdentifier(`/${t.value}/`)],
+                                [ts.factory.createIdentifier(`/${t.value}/`)],
                             );
 
-                    const tail = RandomRanger.length(tsc)(
-                        COALESCE(tsc)(importer),
-                    )({
+                    const tail = RandomRanger.length(COALESCE(importer))({
                         minimum: 5,
                         maximum: 25,
                         gap: 5,
@@ -417,28 +445,145 @@ export namespace RandomProgrammer {
                         minimum: "minLength",
                         maximum: "maxLength",
                     })(tags);
-                    return tsc.factory.createCallExpression(
-                        COALESCE(tsc)(importer)("string"),
+                    return ts.factory.createCallExpression(
+                        COALESCE(importer)("string"),
                         undefined,
                         tail ? [tail] : undefined,
                     );
                 })(),
             );
+
+    const decode_array =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (
+            array: MetadataArray,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ) => {
+            const length: ts.Expression | undefined = RandomRanger.length(
+                COALESCE(importer),
+            )({
+                minimum: 0,
+                maximum: 3,
+                gap: 3,
+            })({
+                fixed: "items",
+                minimum: "minItems",
+                maximum: "maxItems",
+            })(tags);
+            if (array.recursive)
+                return ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        importer.useLocal(PREFIX.array(array.index!)),
+                    ),
+                    undefined,
+                    [
+                        length ?? COALESCE(importer)("length"),
+                        ts.factory.createTrue(),
+                        explore.recursive
+                            ? ts.factory.createAdd(
+                                  ts.factory.createNumericLiteral(1),
+                                  ts.factory.createIdentifier("_depth"),
+                              )
+                            : ts.factory.createNumericLiteral(0),
+                    ],
+                );
+            const expr: ts.Expression = RandomJoiner.array(COALESCE(importer))(
+                decode(importer)(explore),
+            )(explore)(length)(array.value, tags, comments);
+            return explore.recursive
+                ? ts.factory.createConditionalExpression(
+                      ts.factory.createLogicalAnd(
+                          ts.factory.createIdentifier("_recursive"),
+                          ts.factory.createLessThan(
+                              ts.factory.createNumericLiteral(5),
+                              ts.factory.createIdentifier("_depth"),
+                          ),
+                      ),
+                      undefined,
+                      ts.factory.createIdentifier("[]"),
+                      undefined,
+                      expr,
+                  )
+                : expr;
+        };
+
+    const decode_tuple =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (
+            tuple: MetadataTuple,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ): ts.Expression =>
+            tuple.recursive
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(PREFIX.tuple(tuple.index!)),
+                      ),
+                      undefined,
+                      [
+                          ts.factory.createTrue(),
+                          explore.recursive
+                              ? ts.factory.createAdd(
+                                    ts.factory.createNumericLiteral(1),
+                                    ts.factory.createIdentifier("_depth"),
+                                )
+                              : ts.factory.createNumericLiteral(0),
+                      ],
+                  )
+                : RandomJoiner.tuple(decode(importer)(explore))(
+                      tuple.elements,
+                      tags,
+                      comments,
+                  );
+
+    const decode_object =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (object: MetadataObject) =>
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    importer.useLocal(PREFIX.object(object.index)),
+                ),
+                undefined,
+                explore.function
+                    ? [
+                          explore.recursive
+                              ? ts.factory.createTrue()
+                              : ts.factory.createIdentifier("_recursive"),
+                          ts.factory.createConditionalExpression(
+                              ts.factory.createIdentifier("_recursive"),
+                              undefined,
+                              ts.factory.createAdd(
+                                  ts.factory.createNumericLiteral(1),
+                                  ts.factory.createIdentifier("_depth"),
+                              ),
+                              undefined,
+                              ts.factory.createIdentifier("_depth"),
+                          ),
+                      ]
+                    : undefined,
+            );
 }
 
 type Atomic = boolean | number | string | bigint;
 interface IExplore {
-    object: boolean;
+    function: boolean;
     recursive: boolean;
 }
 
-const FUNCTOR = (i: number) => `$ro${i}`;
-const COALESCE =
-    (tsc: typeof ts) => (importer: FunctionImporter) => (name: string) =>
-        ExpressionFactory.coalesce(tsc)(
-            tsc.factory.createPropertyAccessChain(
-                tsc.factory.createIdentifier("generator"),
-                tsc.factory.createToken(tsc.SyntaxKind.QuestionDotToken),
-                tsc.factory.createIdentifier(name),
-            ),
-        )(IdentifierFactory.access(tsc)(importer.use("generator"))(name));
+const PREFIX = {
+    object: (i: number) => `$ro${i}`,
+    array: (i: number) => `$ra${i}`,
+    tuple: (i: number) => `$rt${i}`,
+};
+const COALESCE = (importer: FunctionImporter) => (name: string) =>
+    ExpressionFactory.coalesce(
+        ts.factory.createPropertyAccessChain(
+            ts.factory.createIdentifier("generator"),
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            ts.factory.createIdentifier(name),
+        ),
+    )(IdentifierFactory.access(importer.use("generator"))(name));