typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230824

package/src/programmers/CheckerProgrammer.ts

@@ -9,11 +9,14 @@ import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../transformers/IProject";
 
@@ -24,8 +27,8 @@ import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
-import { check_array } from "./internal/check_array";
 import { check_array_length } from "./internal/check_array_length";
+import { check_array_tags } from "./internal/check_array_tags";
 import { check_bigint } from "./internal/check_bigint";
 import { check_native } from "./internal/check_native";
 import { check_number } from "./internal/check_number";
@@ -150,6 +153,7 @@ export namespace CheckerProgrammer {
                                 },
                                 [],
                                 [],
+                                [],
                             ),
                         ),
                     ),
@@ -292,7 +296,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            metaTags: IMetadataTag[],
+            metaTags: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             if (meta.any) return config.success;
@@ -354,35 +358,40 @@ export namespace CheckerProgrammer {
                         add(true, getConstantValue(val));
 
             // ATOMIC VALUES
-            for (const type of meta.atomics)
-                if (AtomicPredicator.atomic(meta)(type) === false) continue;
-                else if (type === "number")
+            for (const atom of meta.atomics)
+                if (AtomicPredicator.atomic(meta)(atom.type) === false)
+                    continue;
+                else if (atom.type === "number")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_number(project, config.numeric)(importer)(
+                            check_number(project, config.numeric)(
+                                atom.tags,
                                 metaTags,
-                            )(jsDocTags)(input),
+                            )(input),
                         )(input),
                         combined: false,
                     });
-                else if (type === "bigint")
+                else if (atom.type === "bigint")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_bigint(importer)(metaTags)(jsDocTags)(input),
+                            check_bigint(project)(atom.tags, metaTags)(input),
                         )(input),
                         combined: false,
                     });
-                else if (type === "string")
+                else if (atom.type === "string")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_string(importer)(metaTags)(jsDocTags)(input),
+                            check_string(project)(importer)(
+                                atom.tags,
+                                metaTags,
+                            )(input),
                         )(input),
                         combined: false,
                     });
                 else
                     add(
                         true,
-                        ts.factory.createStringLiteral(type),
+                        ts.factory.createStringLiteral(atom.type),
                         ValueFactory.TYPEOF(input),
                     );
 
@@ -391,9 +400,7 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.template(meta))
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_template(importer)(metaTags)(jsDocTags)(
-                                meta.templates,
-                            )(input),
+                            check_template(meta.templates)(input),
                         )(input),
                         combined: false,
                     });
@@ -475,13 +482,12 @@ export namespace CheckerProgrammer {
             // ARRAYS AND TUPLES
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
-                    config.atomist(explore)(
-                        check_array(importer)(
-                            meta.tuples.length === 0 ? metaTags : [],
-                        )(jsDocTags)(input),
-                    )(input),
+                    config.atomist(explore)({
+                        expression: ExpressionFactory.isArray(input),
+                        tags: [],
+                    })(input),
                     [...meta.tuples, ...meta.arrays]
-                        .map((elem) => elem.name)
+                        .map((elem) => elem.type.name)
                         .join(" | "),
                 );
                 if (meta.arrays.length === 0)
@@ -512,7 +518,7 @@ export namespace CheckerProgrammer {
                                 jsDocTags,
                             ),
                         );
-                else if (meta.arrays.some((elem) => elem.value.any))
+                else if (meta.arrays.some((elem) => elem.type.value.any))
                     install(null);
                 else if (meta.tuples.length === 0)
                     if (meta.arrays.length === 1)
@@ -668,14 +674,15 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             array: MetadataArray,
             explore: IExplore,
-            metaTags: IMetadataTag[],
+            metaTags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ) => {
-            if (array.recursive === false)
+            if (array.type.recursive === false)
                 return decode_array_inline(project)(config)(importer)(
                     input,
-                    array,
+                    array.type,
                     explore,
+                    array.tags,
                     metaTags,
                     jsDocTags,
                 );
@@ -688,7 +695,9 @@ export namespace CheckerProgrammer {
             return ts.factory.createLogicalOr(
                 ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(`${config.prefix}a${array.index}`),
+                        importer.useLocal(
+                            `${config.prefix}a${array.type.index}`,
+                        ),
                     ),
                     undefined,
                     FeatureProgrammer.argumentsArray(config)({
@@ -697,7 +706,7 @@ export namespace CheckerProgrammer {
                         from: "array",
                     })(input),
                 ),
-                config.joiner.failure(input, array.name, explore),
+                config.joiner.failure(input, array.type.name, explore),
             );
         };
 
@@ -705,12 +714,34 @@ export namespace CheckerProgrammer {
         (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-            FeatureProgrammer.decode_array({
+        (
+            input: ts.Expression,
+            array: MetadataArrayType,
+            explore: IExplore,
+            matrix: IMetadataTypeTag[][],
+            metaTags: IMetadataCommentTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression => {
+            const tagger = check_array_tags(project)(matrix, metaTags)(input);
+            const main = FeatureProgrammer.decode_array({
                 prefix: config.prefix,
                 trace: config.trace,
                 path: config.path,
                 decoder: () => decode(project)(config)(importer),
-            })(importer)(config.joiner.array);
+            })(importer)(config.joiner.array)(
+                input,
+                array,
+                explore,
+                metaTags,
+                jsDocTags,
+            );
+            return tagger.expression === null && tagger.tags.length === 0
+                ? main
+                : ts.factory.createLogicalAnd(
+                      config.atomist(explore)(tagger)(input),
+                      main,
+                  );
+        };
 
     const decode_tuple =
         (project: IProject) =>
@@ -720,13 +751,13 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuple: MetadataTuple,
             explore: IExplore,
-            tagList: IMetadataTag[],
+            tagList: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
-            if (tuple.recursive === false)
+            if (tuple.type.recursive === false)
                 return decode_tuple_inline(project)(config)(importer)(
                     input,
-                    tuple,
+                    tuple.type,
                     explore,
                     tagList,
                     jsDocTags,
@@ -739,7 +770,9 @@ export namespace CheckerProgrammer {
             return ts.factory.createLogicalOr(
                 ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(`${config.prefix}t${tuple.index}`),
+                        importer.useLocal(
+                            `${config.prefix}t${tuple.type.index}`,
+                        ),
                     ),
                     undefined,
                     FeatureProgrammer.argumentsArray(config)({
@@ -747,7 +780,7 @@ export namespace CheckerProgrammer {
                         source: "function",
                     })(input),
                 ),
-                config.joiner.failure(input, tuple.name, explore),
+                config.joiner.failure(input, tuple.type.name, explore),
             );
         };
 
@@ -757,9 +790,9 @@ export namespace CheckerProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: IExplore,
-            tagList: IMetadataTag[],
+            tagList: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             const binaries: ts.Expression[] = tuple.elements
@@ -882,7 +915,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             sets: Metadata[],
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
@@ -908,7 +941,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             maps: Metadata.Entry[],
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
@@ -964,7 +997,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuples: MetadataTuple[],
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
@@ -988,7 +1021,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             arrays: MetadataArray[],
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
@@ -1012,7 +1045,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             elements: Array<MetadataArray | MetadataTuple>,
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
@@ -1071,7 +1104,7 @@ export namespace CheckerProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -1079,7 +1112,7 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             elements: T[],
             explore: IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: IJsDocTagInfo[],
         ): ts.Expression => {
             const arrow =
@@ -1093,7 +1126,7 @@ export namespace CheckerProgrammer {
                         tags,
                         jsDocTags,
                     );
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -1109,7 +1142,7 @@ export namespace CheckerProgrammer {
                     ts.factory.createIdentifier(
                         importer.emplaceUnion(
                             config.prefix,
-                            elements.map((e) => e.name).join(" | "),
+                            elements.map((e) => e.type.name).join(" | "),
                             () =>
                                 arrow(
                                     FeatureProgrammer.parameterDeclarations(
@@ -1128,7 +1161,7 @@ export namespace CheckerProgrammer {
                 ),
                 config.joiner.failure(
                     input,
-                    elements.map((e) => e.name).join(" | "),
+                    elements.map((e) => e.type.name).join(" | "),
                     explore,
                 ),
             );

package/src/programmers/FeatureProgrammer.ts

@@ -7,9 +7,9 @@ import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
@@ -195,7 +195,7 @@ export namespace FeatureProgrammer {
             input: ts.Expression,
             target: T,
             explore: IExplore,
-            metaTags: IMetadataTag[],
+            metaTags: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): Output;
     }
@@ -349,7 +349,7 @@ export namespace FeatureProgrammer {
             combiner: (
                 input: ts.Expression,
                 arrow: ts.ArrowFunction,
-                metaTags: IMetadataTag[],
+                metaTags: IMetadataCommentTag[],
                 jsDocTags: ts.JSDocTagInfo[],
             ) => ts.Expression,
         ) => {
@@ -366,9 +366,9 @@ export namespace FeatureProgrammer {
 
             return (
                 input: ts.Expression,
-                array: MetadataArray,
+                array: MetadataArrayType,
                 explore: IExplore,
-                metaTags: IMetadataTag[],
+                metaTags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => {
                 const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(

package/src/programmers/IsProgrammer.ts

@@ -31,7 +31,7 @@ export namespace IsProgrammer {
             }),
             atomist: () => (entry) => () =>
                 [
-                    entry.expression,
+                    ...(entry.expression ? [entry.expression] : []),
                     ...entry.tags.map((tag) => tag.expression),
                 ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {

package/src/programmers/RandomProgrammer.ts

@@ -9,11 +9,13 @@ import { TemplateFactory } from "../factories/TemplateFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 
 import { ICommentTag } from "../schemas/metadata/ICommentTag";
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../transformers/IProject";
 
@@ -225,7 +227,7 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             meta: Metadata,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression => {
             const expressions: ts.Expression[] = [];
@@ -248,14 +250,14 @@ export namespace RandomProgrammer {
             // ATOMIC VARIABLES
             for (const template of meta.templates)
                 expressions.push(decode_template(importer)(explore)(template));
-            for (const atomic of meta.atomics)
-                if (atomic === "boolean")
+            for (const a of meta.atomics)
+                if (a.type === "boolean")
                     expressions.push(decode_boolean(importer));
-                else if (atomic === "number")
+                else if (a.type === "number")
                     expressions.push(decode_number(importer)(tags, comments));
-                else if (atomic === "string")
+                else if (a.type === "string")
                     expressions.push(decode_string(importer)(tags, comments));
-                else if (atomic === "bigint")
+                else if (a.type === "bigint")
                     expressions.push(decode_bigint(importer)(tags, comments));
 
             // INSTANCE TYPES
@@ -343,7 +345,10 @@ export namespace RandomProgrammer {
 
     const decode_number =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[], comments: ICommentTag[]): ts.Expression => {
+        (
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
             const type = tags.find(
                 (t) =>
                     t.kind === "type" &&
@@ -391,7 +396,7 @@ export namespace RandomProgrammer {
 
     const decode_bigint =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[], comments: ICommentTag[]): ts.Expression =>
+        (tags: IMetadataCommentTag[], comments: ICommentTag[]): ts.Expression =>
             random_custom(COALESCE(importer))("bigint")(comments)(
                 RandomRanger.number({
                     type: tags.find(
@@ -419,7 +424,7 @@ export namespace RandomProgrammer {
 
     const decode_string =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[], comments: ICommentTag[]): ts.Expression =>
+        (tags: IMetadataCommentTag[], comments: ICommentTag[]): ts.Expression =>
             random_custom(COALESCE(importer))("string")(comments)(
                 (() => {
                     for (const t of tags)
@@ -458,7 +463,7 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             array: MetadataArray,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ) => {
             const length: ts.Expression | undefined = RandomRanger.length(
@@ -472,10 +477,10 @@ export namespace RandomProgrammer {
                 minimum: "minItems",
                 maximum: "maxItems",
             })(tags);
-            if (array.recursive)
+            if (array.type.recursive)
                 return ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(PREFIX.array(array.index!)),
+                        importer.useLocal(PREFIX.array(array.type.index!)),
                     ),
                     undefined,
                     [
@@ -491,7 +496,7 @@ export namespace RandomProgrammer {
                 );
             const expr: ts.Expression = RandomJoiner.array(COALESCE(importer))(
                 decode(importer)(explore),
-            )(explore)(length)(array.value, tags, comments);
+            )(explore)(length)(array.type.value, tags, comments);
             return explore.recursive
                 ? ts.factory.createConditionalExpression(
                       ts.factory.createLogicalAnd(
@@ -514,13 +519,13 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             tuple: MetadataTuple,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(PREFIX.tuple(tuple.index!)),
+                          importer.useLocal(PREFIX.tuple(tuple.type.index!)),
                       ),
                       undefined,
                       [
@@ -534,7 +539,7 @@ export namespace RandomProgrammer {
                       ],
                   )
                 : RandomJoiner.tuple(decode(importer)(explore))(
-                      tuple.elements,
+                      tuple.type.elements,
                       tags,
                       comments,
                   );
@@ -573,18 +578,25 @@ export namespace RandomProgrammer {
     const decode_set =
         (importer: FunctionImporter) =>
         (explore: IExplore) =>
-        (meta: Metadata, tags: IMetadataTag[], comments: ICommentTag[]) =>
+        (
+            meta: Metadata,
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ) =>
             ts.factory.createNewExpression(
                 ts.factory.createIdentifier("Set"),
                 undefined,
                 [
                     decode_array(importer)(explore)(
                         MetadataArray.create({
-                            value: meta,
-                            recursive: false,
-                            index: null,
-                            nullables: [],
-                            name: `Set<${meta.getName()}>`,
+                            tags: [],
+                            type: MetadataArrayType.create({
+                                value: meta,
+                                recursive: false,
+                                index: null,
+                                nullables: [],
+                                name: `Set<${meta.getName()}>`,
+                            }),
                         }),
                         tags,
                         comments,
@@ -595,32 +607,43 @@ export namespace RandomProgrammer {
     const decode_map =
         (importer: FunctionImporter) =>
         (explore: IExplore) =>
-        (m: Metadata.Entry, tags: IMetadataTag[], comments: ICommentTag[]) =>
+        (
+            m: Metadata.Entry,
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ) =>
             ts.factory.createNewExpression(
                 ts.factory.createIdentifier("Map"),
                 undefined,
                 [
                     decode_array(importer)(explore)(
                         MetadataArray.create({
-                            name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
-                            index: null,
-                            recursive: false,
-                            nullables: [],
-                            value: Metadata.create({
-                                ...Metadata.initialize(),
-                                tuples: [
-                                    (() => {
-                                        const tuple = MetadataTuple.create({
-                                            name: `[${m.key.getName()}, ${m.value.getName()}]`,
-                                            index: null,
-                                            recursive: false,
-                                            nullables: [],
-                                            elements: [m.key, m.value],
-                                        });
-                                        tuple.of_map = true;
-                                        return tuple;
-                                    })(),
-                                ],
+                            tags: [],
+                            type: MetadataArrayType.create({
+                                name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                                index: null,
+                                recursive: false,
+                                nullables: [],
+                                value: Metadata.create({
+                                    ...Metadata.initialize(),
+                                    tuples: [
+                                        (() => {
+                                            const type =
+                                                MetadataTupleType.create({
+                                                    name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                                    index: null,
+                                                    recursive: false,
+                                                    nullables: [],
+                                                    elements: [m.key, m.value],
+                                                });
+                                            type.of_map = true;
+                                            return MetadataTuple.create({
+                                                type,
+                                                tags: [],
+                                            });
+                                        })(),
+                                    ],
+                                }),
                             }),
                         }),
                         tags,
@@ -633,7 +656,7 @@ export namespace RandomProgrammer {
         (importer: FunctionImporter) =>
         (
             type: string,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression => {
             if (type === "Boolean") return decode_boolean(importer);

package/src/programmers/ValidateProgrammer.ts

@@ -36,7 +36,7 @@ export namespace ValidateProgrammer {
                     equals,
                     atomist: (explore) => (tuple) => (input) =>
                         [
-                            tuple.expression,
+                            ...(tuple.expression ? [tuple.expression] : []),
                             ...tuple.tags.map((tag) =>
                                 ts.factory.createLogicalOr(
                                     tag.expression,

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,7 +8,7 @@ export namespace AtomicPredicator {
     export const constant =
         (meta: Metadata) =>
         (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
             !ArrayUtil.has(
                 meta.natives,
                 (native) => native.toLowerCase() === name,
@@ -25,7 +25,7 @@ export namespace AtomicPredicator {
     export const native = (name: string) => LIKE.has(name.toLowerCase());
 
     export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (type) => type === "string");
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
 }
 
 const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 export interface ICheckEntry {
-    expression: ts.Expression;
+    expression: ts.Expression | null;
     tags: ICheckEntry.ITag[];
 }
 export namespace ICheckEntry {