@litert/typeguard 1.0.1 → 1.3.0-dev.0

package/src/lib/Compiler.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,23 +14,22 @@
  * limitations under the License.
  */
 
-import * as I from "./Internal";
-import * as C from "./Common";
-import * as M from "./Modifiers";
-import { Context } from "./Context";
-import * as B from "./BuiltInTypes";
-import { BuiltInTypeCompiler } from "./BuiltInTypeCompiler";
-import { FilterCompiler } from "./FilterCompiler";
+import * as I from './Internal';
+import * as C from './Common';
+import * as M from './Modifiers';
+import { Context } from './Context';
+import * as B from './BuiltInTypes';
+import { BuiltInTypeCompiler } from './BuiltInTypeCompiler';
+import { FilterCompiler } from './FilterCompiler';
 
-class Compiler
-implements C.ICompiler {
+class Compiler implements C.ICompiler {
 
     private _defTypes: Record<string, C.ICompileResult>;
 
     public constructor(
-        private _lang: C.ILanguageBuilder,
-        private _builtInTypes: I.IBuiltInTypeCompiler,
-        private _filters: I.IFilterCompiler
+        private readonly _lang: C.ILanguageBuilder,
+        private readonly _builtInTypes: I.IBuiltInTypeCompiler,
+        private readonly _filters: I.IFilterCompiler
     ) {
         this._defTypes = {};
     }
@@ -45,13 +44,44 @@ implements C.ICompiler {
         return null;
     }
 
+    private _addTrace(ctx: I.IContext): string {
+
+        if (!ctx.vTraceName) {
+
+            return this._lang.literalFalse;
+        }
+
+        return this._lang.addTrace(
+            ctx.vTraceName,
+            ctx.vTracePrefix,
+            ctx.tracePath
+        );
+    }
+
+    private _addTraceOr(ctx: I.IContext, expr: string, subPath: string = ''): string {
+
+        if (!ctx.vTraceName) {
+
+            return expr;
+        }
+
+        return this._lang.orAddTrace(
+            expr,
+            ctx.vTraceName,
+            ctx.vTracePrefix,
+            `${ctx.tracePath}${subPath}`
+        );
+    }
+
     public compile(options: C.ICompileOptions): C.ICompileResult {
 
         const referredTypes: Record<string, true> = {};
 
         const ctx: I.IContext = new Context(
-            this._lang.varName("entry"),
-            this._lang.varName("types"),
+            this._lang.varName('entry'),
+            options.traceErrors ? this._lang.varName('failedAsserts') : '',
+            options.traceErrors ? this._lang.varName('tracePrefix') : '',
+            this._lang.varName('types'),
             referredTypes
         );
 
@@ -68,15 +98,31 @@ implements C.ICompiler {
 
             const ret: C.ICompileResult = {
 
-                source: "",
+                source: '',
                 arguments: [{
-                    "name": ctx.vName,
-                    "type": "unknown"
+                    'name': ctx.vName,
+                    'type': 'unknown',
+                    'initial': ''
                 }],
                 typeSlotName: ctx.typeSlotName,
                 referredTypes: []
             };
 
+            if (ctx.vTraceName) {
+
+                ret.arguments.push({
+                    'name': ctx.vTraceName,
+                    'type': 'string[]',
+                    'initial': '[]'
+                });
+
+                ret.arguments.push({
+                    'name': ctx.vTracePrefix,
+                    'type': 'string',
+                    'initial': this._lang.literal('data')
+                });
+            }
+
             ret.source = this._compile(
                 ctx,
                 options.rule
@@ -91,82 +137,85 @@ implements C.ICompiler {
     private _compile(ctx: I.IContext, rules: any): string {
 
         switch (typeof rules) {
-        case "string":
+            case 'string':
 
-            return this._compileStringRule(ctx, rules);
+                return this._compileStringRule(ctx, rules);
 
-        case "boolean":
+            case 'boolean':
 
-            if (ctx.flags[I.EFlags.FROM_STRING]) {
-
-                return this._lang.or([
-                    this._lang.eq(
-                        ctx.vName,
-                        this._lang.literal(rules)
-                    ),
-                    this._lang.eq(
-                        this._lang.str2Bool(ctx.vName),
-                        this._lang.literal(rules)
-                    )
-                ]);
-            }
-
-            return this._lang.eq(
-                ctx.vName,
-                this._lang.literal(rules)
-            );
-
-        case "number":
-
-            if (ctx.flags[I.EFlags.FROM_STRING]) {
-
-                return this._lang.or([
-                    this._lang.eq(
-                        ctx.vName,
-                        this._lang.literal(rules)
-                    ),
-                    this._lang.eq(
-                        this._lang.str2Float(ctx.vName),
-                        this._lang.literal(rules)
-                    )
-                ]);
-            }
-
-            return this._lang.eq(
-                ctx.vName,
-                this._lang.literal(rules)
-            );
+                if (ctx.flags[I.EFlags.FROM_STRING]) {
 
-        case "object":
+                    return this._lang.or([
+                        this._lang.eq(
+                            ctx.vName,
+                            this._lang.literal(rules)
+                        ),
+                        this._lang.eq(
+                            this._lang.str2Bool(ctx.vName),
+                            this._lang.literal(rules)
+                        )
+                    ]);
+                }
 
-            if (Array.isArray(rules)) {
+                return this._lang.eq(
+                    ctx.vName,
+                    this._lang.literal(rules)
+                );
 
-                return this._compileModifiedRule(ctx, rules);
-            }
-            else if (rules === null) {
+            case 'number':
 
                 if (ctx.flags[I.EFlags.FROM_STRING]) {
 
                     return this._lang.or([
-                        this._lang.isNull(ctx.vName, true),
                         this._lang.eq(
                             ctx.vName,
-                            this._lang.literal("null")
+                            this._lang.literal(rules)
+                        ),
+                        this._lang.eq(
+                            this._lang.str2Float(ctx.vName),
+                            this._lang.literal(rules)
                         )
                     ]);
                 }
 
-                return this._lang.isNull(ctx.vName, true);
-            }
+                return this._lang.eq(
+                    ctx.vName,
+                    this._lang.literal(rules)
+                );
+
+            case 'object':
 
-            return this._compileStructuredRule(ctx, rules);
+                if (Array.isArray(rules)) {
 
-        case "undefined":
+                    return this._compileModifiedRule(ctx, rules);
+                }
+                else if (rules === null) {
+
+                    if (ctx.flags[I.EFlags.FROM_STRING]) {
+
+                        return this._lang.or([
+                            this._lang.isNull(ctx.vName, true),
+                            this._lang.eq(
+                                ctx.vName,
+                                this._lang.literal('null')
+                            )
+                        ]);
+                    }
 
-            return this._lang.isUndefined(ctx.vName, true);
+                    return this._lang.isNull(ctx.vName, true);
+                }
+
+                return this._compileStructuredRule(ctx, rules);
+
+            case 'undefined':
+
+                return this._lang.isUndefined(ctx.vName, true);
+
+            default:
+                break;
         }
 
-        throw new TypeError("Unknwn rules.");
+        throw new TypeError('Unknwn rules.');
     }
 
     private _compileStringRule(ctx: I.IContext, rule: string): string {
@@ -181,7 +230,7 @@ implements C.ICompiler {
             ]);
         }
 
-        if (rule[0] === I.IMPLICIT_SYMBOL) {
+        if (rule.startsWith(I.IMPLICIT_SYMBOL)) {
 
             return this._lang.or([
                 this._builtInTypes.compile(B.VOID, ctx, []),
@@ -189,61 +238,73 @@ implements C.ICompiler {
             ]);
         }
 
-        if (rule[0] === I.NEGATIVE_SYMBOL) {
+        if (rule.startsWith(I.NEGATIVE_SYMBOL)) {
 
             return this._lang.not(this._compileStringRule(ctx, rule.slice(1)));
         }
 
-        let regResult: RegExpMatchArray | null;
+        let regResult: RegExpMatchArray | null = /\[\s*(\d*|\d+\s*,\s*\d*)\s*\]$/.exec(rule);
 
         /**
-         * For rules like `xxx[123]` or `xxx[1,5]`.
+         * For rules like `xxx[123]` or `xxx[1,5]` or `xxx[1,]`.
          */
-        if (regResult = rule.match(/\[\s*(\d*|\d+\s*,\s*\d*)\s*\]$/)) {
+        if (regResult) {
 
             if (regResult[1]) {
 
-                let range = regResult[1].split(",").map((x) => parseInt(x.trim()));
+                const range = regResult[1].split(',').map((x) => parseInt(x.trim()));
 
                 if (range.length === 1) {
 
+                    /**
+                     * For rules like `xxx[123]`.
+                     */
                     return this._compileModifiedRule(ctx, [
                         M.ARRAY,
                         range[0],
-                        rule.substr(0, regResult.index)
+                        rule.slice(0, regResult.index)
                     ]);
                 }
                 else if (Number.isNaN(range[1])) {
 
+                    /**
+                     * For rules like `xxx[1,]`.
+                     */
                     return this._compileModifiedRule(ctx, [
                         M.ARRAY,
                         [range[0]],
-                        rule.substr(0, regResult.index)
+                        rule.slice(0, regResult.index)
                     ]);
                 }
                 else {
 
+                    /**
+                     * For rules like `xxx[1,5]`.
+                     */
                     return this._compileModifiedRule(ctx, [
                         M.ARRAY,
                         range,
-                        rule.substr(0, regResult.index)
+                        rule.slice(0, regResult.index)
                     ]);
                 }
             }
             else {
 
+                /**
+                 * For rules like `xxx[]`.
+                 */
                 return this._compileModifiedRule(ctx, [
                     M.LIST,
-                    rule.substr(0, regResult.index)
+                    rule.slice(0, regResult.index)
                 ]);
             }
         }
 
-        /**
-         * For rules like `xxx{}`.
-         */
         if (rule.endsWith(I.MAP_SUFFIX)) {
 
+            /**
+             * For rules like `xxx{}`.
+             */
             return this._lang.and([
                 this._compileModifiedRule(ctx, [
                     M.MAP,
@@ -252,11 +313,13 @@ implements C.ICompiler {
             ]);
         }
 
-        if (rule[0] === I.PREDEF_TYPE_SYMBOL) {
+        if (rule.startsWith(I.PREDEF_TYPE_SYMBOL)) {
 
             return this._usePredefinedType(ctx, rule.slice(1));
         }
 
+        regResult = /^(\w+)(\(\s*(-?\d+(\.\d+)?)?\s*,?\s*(-?\d+(\.\d+)?)?\s*\))?$/.exec(rule);
+
         /**
          * For built-in-type rules like:
          *
@@ -265,11 +328,11 @@ implements C.ICompiler {
          * - `string`
          * - `int(12, 34)`
          */
-        if (regResult = rule.match(/^(\w+)(\(\s*(-?\d+(\.\d+)?)?\s*,?\s*(-?\d+(\.\d+)?)?\s*\))?$/)) {
+        if (regResult) {
 
             if (regResult[2]) {
 
-                const args = regResult[2].slice(1, -1).trim().split(",").map(
+                const args = regResult[2].slice(1, -1).trim().split(',').map(
                     (x) => parseFloat(x.trim())
                 );
 
@@ -287,7 +350,7 @@ implements C.ICompiler {
             );
         }
 
-        if (rule[0] === I.FILTER_PREFIX) {
+        if (rule.startsWith(I.FILTER_PREFIX)) {
 
             return this._filters.compile(rule, ctx);
         }
@@ -318,162 +381,162 @@ implements C.ICompiler {
         rule: string
     ): string | false {
 
-        const assertRule = rule.match(/^:([-\w]+):/);
+        const assertRule = /^:([-\w]+):/.exec(rule);
 
         const offset = assertRule ? assertRule[1].length + 2 : 2;
 
-        switch ((assertRule && assertRule[1]) || rule.substr(0, 2)) {
-        case "==":
-        case "equal":
+        switch ((assertRule?.[1]) ?? rule.slice(0, 2)) {
+            case '==':
+            case 'equal':
 
-            return this._lang.eq(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            );
+                return this._lang.eq(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                );
 
-        case "%=":
-        case "equal-i":
+            case '%=':
+            case 'equal-i':
 
-            return this._lang.eq(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            );
+                return this._lang.eq(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                );
 
-        case "!=":
-        case "not-equal":
+            case '!=':
+            case 'not-equal':
 
-            return this._lang.ne(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            );
+                return this._lang.ne(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                );
 
-        case "%!":
-        case "not-equal-i":
+            case '%!':
+            case 'not-equal-i':
 
-            return this._lang.ne(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            );
+                return this._lang.ne(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                );
 
-        case "~=":
-        case "match":
+            case '~=':
+            case 'match':
 
-            return this._lang.matchRegExp(
-                ctx.vName,
-                rule.slice(offset)
-            );
+                return this._lang.matchRegExp(
+                    ctx.vName,
+                    rule.slice(offset)
+                );
 
-        case "~!":
-        case "not-match":
+            case '~!':
+            case 'not-match':
 
-            return this._lang.not(this._lang.matchRegExp(
-                ctx.vName,
-                rule.slice(offset)
-            ));
+                return this._lang.not(this._lang.matchRegExp(
+                    ctx.vName,
+                    rule.slice(offset)
+                ));
 
-        case "?=":
-        case "include":
+            case '?=':
+            case 'include':
 
-            return this._lang.instr(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            );
+                return this._lang.instr(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                );
 
-        case "?!":
-        case "not-include":
+            case '?!':
+            case 'not-include':
 
-            return this._lang.not(this._lang.instr(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            ));
+                return this._lang.not(this._lang.instr(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                ));
 
-        case "*=":
-        case "include-i":
+            case '*=':
+            case 'include-i':
 
-            return this._lang.instr(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            );
+                return this._lang.instr(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                );
 
-        case "*!":
-        case "not-include-i":
+            case '*!':
+            case 'not-include-i':
 
-            return this._lang.not(this._lang.instr(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            ));
+                return this._lang.not(this._lang.instr(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                ));
 
-        case "^=":
-        case "start-with":
+            case '^=':
+            case 'start-with':
 
-            return this._lang.startsWith(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            );
+                return this._lang.startsWith(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                );
 
-        case "start-with-i":
+            case 'start-with-i':
 
-            return this._lang.startsWith(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            );
+                return this._lang.startsWith(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                );
 
-        case "^!":
-        case "not-start-with":
+            case '^!':
+            case 'not-start-with':
 
-            return this._lang.not(this._lang.startsWith(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            ));
+                return this._lang.not(this._lang.startsWith(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                ));
 
-        case "not-start-with-i":
+            case 'not-start-with-i':
 
-            return this._lang.not(this._lang.startsWith(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            ));
+                return this._lang.not(this._lang.startsWith(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                ));
 
-        case "$=":
-        case "end-with":
+            case '$=':
+            case 'end-with':
 
-            return this._lang.endsWith(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            );
+                return this._lang.endsWith(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                );
 
-        case "end-with-i":
+            case 'end-with-i':
 
-            return this._lang.endsWith(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            );
+                return this._lang.endsWith(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                );
 
-        case "$!":
-        case "not-end-with":
+            case '$!':
+            case 'not-end-with':
 
-            return this._lang.not(this._lang.endsWith(
-                ctx.vName,
-                this._lang.literal(rule.slice(offset))
-            ));
+                return this._lang.not(this._lang.endsWith(
+                    ctx.vName,
+                    this._lang.literal(rule.slice(offset))
+                ));
 
-        case "not-end-with-i":
+            case 'not-end-with-i':
 
-            return this._lang.not(this._lang.endsWith(
-                this._lang.lowerCase(ctx.vName),
-                this._lang.literal(rule.slice(offset).toLowerCase())
-            ));
+                return this._lang.not(this._lang.endsWith(
+                    this._lang.lowerCase(ctx.vName),
+                    this._lang.literal(rule.slice(offset).toLowerCase())
+                ));
 
-        default:
+            default:
 
-            if (rule.startsWith("=")) {
+                if (rule.startsWith('=')) {
 
-                return this._lang.eq(ctx.vName, this._lang.literal(rule.slice(1)));
-            }
+                    return this._lang.eq(ctx.vName, this._lang.literal(rule.slice(1)));
+                }
 
-            if (rule.startsWith("~")) {
+                if (rule.startsWith('~')) {
 
-                return this._lang.matchRegExp(ctx.vName, rule.slice(1));
-            }
+                    return this._lang.matchRegExp(ctx.vName, rule.slice(1));
+                }
         }
 
         return false;
@@ -483,14 +546,14 @@ implements C.ICompiler {
 
         if (!rules.length) {
 
-            throw new TypeError(`Unknwon type "[]".`);
+            throw new TypeError('Unknwon type "[]".');
         }
 
         /**
          * By default, use OR modifier.
          */
         if (
-            typeof rules[0] !== "string" ||
+            typeof rules[0] !== 'string' ||
             !rules[0].startsWith(I.MODIFIER_PREFIX)
         ) {
 
@@ -574,7 +637,7 @@ implements C.ICompiler {
 
     private _compileModifierOR(ctx: I.IContext, rules: any[]): string {
 
-        let result: string[] = [];
+        const result: string[] = [];
 
         for (const r of rules) {
 
@@ -595,7 +658,7 @@ implements C.ICompiler {
         );
     }
 
-    private _compileModifierLIST(ctx: I.IContext, rules: any[]): string {
+    private _compileModifierLIST(ctx: I.IContext, rules: any[], traceOffset: number = 0): string {
 
         const result: string[] = [];
 
@@ -613,6 +676,10 @@ implements C.ICompiler {
         const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
 
         ctx.vName = this._lang.varName(ctx.vCursor++);
+        const vIter = this._lang.varName(ctx.vCursor++);
+        ctx.tracePath = `${ctx.tracePath}[${this._lang.numberTemplateVar(
+            traceOffset ? this._lang.add(traceOffset, vIter) : vIter
+        )}]`;
 
         if (rules[0] !== B.ANY) {
 
@@ -621,9 +688,9 @@ implements C.ICompiler {
                 [CLOSURE_ARG],
                 this._lang.series([
                     this._lang.forEach(
-                        CLOSURE_PARAM, ctx.vName, this._lang.ifThen(
+                        CLOSURE_PARAM, vIter, ctx.vName, this._lang.ifThen(
                             this._lang.not(this._compile(ctx, rules)),
-                            this._lang.returnValue(this._lang.literal(false))
+                            this._lang.returnValue(this._addTrace(ctx))
                         )
                     ),
                     this._lang.returnValue(this._lang.literal(true))
@@ -636,7 +703,7 @@ implements C.ICompiler {
         return this._lang.and(result);
     }
 
-    private _compileModifierARRAY(ctx: I.IContext, rules: any[]): string {
+    private _compileModifierARRAY(ctx: I.IContext, rules: any[], traceOffset: number = 0): string {
 
         let a: number = 0;
         let b: number = -1;
@@ -716,6 +783,10 @@ implements C.ICompiler {
         const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
 
         ctx.vName = this._lang.varName(ctx.vCursor++);
+        const vIter = this._lang.varName(ctx.vCursor++);
+        ctx.tracePath = `${ctx.tracePath}[${this._lang.numberTemplateVar(
+            traceOffset ? this._lang.add(traceOffset, vIter) : vIter
+        )}]`;
 
         switch (b) {
             case -1: {
@@ -749,9 +820,9 @@ implements C.ICompiler {
                 [CLOSURE_ARG],
                 this._lang.series([
                     this._lang.forEach(
-                        CLOSURE_PARAM, ctx.vName, this._lang.ifThen(
+                        CLOSURE_PARAM, vIter, ctx.vName, this._lang.ifThen(
                             this._lang.not(this._compile(ctx, rules.slice(1))),
-                            this._lang.returnValue(this._lang.literal(false))
+                            this._lang.returnValue(this._addTrace(ctx))
                         )
                     ),
                     this._lang.returnValue(this._lang.literal(true))
@@ -781,6 +852,7 @@ implements C.ICompiler {
 
         const types = rules.slice();
         let tupleLength = 0;
+        let tupleLengthMin = 0;
 
         while (1) {
 
@@ -791,18 +863,18 @@ implements C.ICompiler {
                 break;
             }
 
-            if (typeof type === "string" && type.startsWith("...")) {
+            if (typeof type === 'string' && type.startsWith('...')) {
 
                 throw new TypeError(`Invalid syntax for tuple: ${JSON.stringify(rules)}`);
             }
 
-            if (typeof types[0] === "string" && types[0].startsWith("...")) {
+            if (typeof types[0] === 'string' && types[0].startsWith('...')) {
 
                 ctx.trap();
 
                 dots = types.shift();
 
-                if (dots === "...") {
+                if (dots === '...') {
 
                     /**
                      * No more elements because "..." means all rest elements.
@@ -814,13 +886,14 @@ implements C.ICompiler {
 
                     ctx.vName = this._lang.arraySlice(ctx.vName, i);
 
-                    if (type !== "any") {
+                    if (type !== 'any') {
 
                         result.push(this._compileModifierLIST(
-                            ctx, type
+                            ctx, type, i
                         ));
                     }
 
+                    tupleLengthMin = tupleLength;
                     tupleLength = -1;
                 }
                 else if (!/^\d+$/.test(dots.slice(3))) {
@@ -831,22 +904,27 @@ implements C.ICompiler {
 
                     const length = parseInt(dots.slice(3));
 
-                    if (length <= 3) {
+                    if (length === 0) {
 
-                        const vName = ctx.vName;
+                        throw new TypeError(`Invalid syntax for tuple: ${dots}`);
+                    }
+                    else if (length === 1) {
 
-                        for (let j = 0; j < length; j++) {
+                        const vName = ctx.vName;
 
-                            ctx.vName = this._lang.arrayIndex(vName, i++);
-                            result.push(this._compile(ctx, type));
-                        }
+                        ctx.tracePath = `${ctx.tracePath}[${i}]`;
+                        ctx.vName = this._lang.arrayIndex(vName, i++);
+                        result.push(this._addTraceOr(
+                            ctx,
+                            this._compile(ctx, type),
+                        ));
                     }
                     else {
 
                         ctx.vName = this._lang.arraySlice(ctx.vName, i, i + length);
 
                         result.push(this._compileModifierARRAY(
-                            ctx, [length, type]
+                            ctx, [length, type], i
                         ));
 
                         i += length;
@@ -859,8 +937,12 @@ implements C.ICompiler {
 
                 ctx.trap(true);
 
+                ctx.tracePath = `${ctx.tracePath}[${i}]`;
                 ctx.vName = this._lang.arrayIndex(ctx.vName, i++);
-                result.push(this._compile(ctx, type));
+                result.push(this._addTraceOr(
+                    ctx,
+                    this._compile(ctx, type),
+                ));
                 tupleLength++;
             }
 
@@ -869,9 +951,24 @@ implements C.ICompiler {
 
         if (tupleLength >= 0) {
 
-            result.splice(1, -1, this._lang.eq(
-                this._lang.arrayLength(ctx.vName),
-                tupleLength
+            result.splice(1, -1, this._addTraceOr(
+                ctx,
+                this._lang.eq(
+                    this._lang.arrayLength(ctx.vName),
+                    tupleLength
+                ),
+                '.length'
+            ));
+        }
+        else if (tupleLengthMin >= 0) {
+
+            result.splice(1, -1, this._addTraceOr(
+                ctx,
+                this._lang.gte(
+                    this._lang.arrayLength(ctx.vName),
+                    tupleLengthMin
+                ),
+                '.length'
             ));
         }
 
@@ -880,7 +977,7 @@ implements C.ICompiler {
 
     private _validateTypeName(name: unknown): void {
 
-        if (typeof name !== "string" || !/^\w+$/.test(name)) {
+        if (typeof name !== 'string' || !I.RE_VALID_CUSTOM_TYPE_NAME.test(name)) {
 
             throw new TypeError(`Invalid name ${
                 JSON.stringify(name)
@@ -898,7 +995,8 @@ implements C.ICompiler {
         }
 
         this._defTypes[rules[0]] = this.compile({
-            rule: rules.slice(1)
+            rule: rules.slice(1),
+            traceErrors: !!ctx.vTraceName
         });
 
         return this._usePredefinedType(ctx, rules[0]);
@@ -949,24 +1047,25 @@ implements C.ICompiler {
 
         ctx.trap(true);
 
-        const CLOSURE_ARG = ctx.vName;
+        const vCArg = ctx.vName;
 
-        const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
+        const vCParam = this._lang.varName(ctx.vCursor++);
 
-        const FOR_IN_KEY = this._lang.varName(ctx.vCursor++);
+        const vKey = this._lang.varName(ctx.vCursor++);
 
         ctx.vName = this._lang.varName(ctx.vCursor++);
+        ctx.tracePath = `${ctx.tracePath}[${this._lang.stringTemplateVar(vKey)}]`;
 
         const result = this._lang.and([
-            this._lang.isStrucutre(CLOSURE_ARG, true),
+            this._lang.isStrucutre(vCArg, true),
             this._lang.closure(
-                [CLOSURE_PARAM],
-                [CLOSURE_ARG],
+                [vCParam],
+                [vCArg],
                 this._lang.series([
                     this._lang.forIn(
-                        CLOSURE_PARAM, FOR_IN_KEY, ctx.vName, this._lang.ifThen(
+                        vCParam, vKey, ctx.vName, this._lang.ifThen(
                             this._lang.not(this._compile(ctx, rules)),
-                            this._lang.returnValue(this._lang.literal(false))
+                            this._lang.returnValue(this._addTrace(ctx))
                         )
                     ),
                     this._lang.returnValue(this._lang.literal(true))
@@ -986,7 +1085,7 @@ implements C.ICompiler {
             throw new SyntaxError(`Invalid dict ${JSON.stringify(rules)}.`);
         }
 
-        let tmp: Record<string, string> = {};
+        const tmp: Record<string, string> = {};
 
         const id = `${Date.now()}${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}`;
 
@@ -997,9 +1096,9 @@ implements C.ICompiler {
 
         const type = `${I.PREDEF_TYPE_SYMBOL}${this._lang.varName(id)}`;
 
-        for (let key of rules[0]) {
+        for (const key of rules[0]) {
 
-            if (typeof key !== "string") {
+            if (typeof key !== 'string') {
 
                 throw new SyntaxError(`Invalid key ${JSON.stringify(key)} for dict.`);
             }
@@ -1018,7 +1117,11 @@ implements C.ICompiler {
         const strict = !!ctx.flags[I.EFlags.STRICT];
 
         const result: string[] = [
-            this._lang.isStrucutre(ctx.vName, true)
+            this._addTraceOr(
+                ctx,
+                this._lang.isStrucutre(ctx.vName, true),
+                '!object'
+            )
         ];
 
         const keys: string[] = [];
@@ -1059,7 +1162,7 @@ implements C.ICompiler {
             }
             else {
 
-                const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
+                const matchResult = I.KEY_ARRAY_SUFFIX.exec(k);
 
                 if (matchResult) {
 
@@ -1102,8 +1205,12 @@ implements C.ICompiler {
             keys.push(k);
 
             ctx.vName = this._lang.fieldIndex(ctx.vName, this._lang.literal(k));
+            ctx.tracePath = `${ctx.tracePath}[${this._lang.literal(k)}]`;
 
-            result.push(this._compile(ctx, rule));
+            result.push(this._addTraceOr(
+                ctx,
+                this._compile(ctx, rule)
+            ));
 
             ctx.untrap();
         }
@@ -1132,7 +1239,7 @@ implements C.ICompiler {
 
         if (mapSymbol.length > 1) {
 
-            throw new SyntaxError("Only one '$.map' is allowed as rest-mapping.");
+            throw new SyntaxError('Only one \'$.map\' is allowed as rest-mapping.');
         }
         else if (mapSymbol.length === 0) {
 
@@ -1193,7 +1300,7 @@ implements C.ICompiler {
             }
             else {
 
-                const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
+                const matchResult = I.KEY_ARRAY_SUFFIX.exec(k);
 
                 if (matchResult) {
 
@@ -1291,7 +1398,7 @@ implements C.ICompiler {
 
         return Array.isArray(rule) && (
             rule[0] === M.OR ||
-            typeof rule[0] !== "string" ||
+            typeof rule[0] !== 'string' ||
             !rule[0].startsWith(I.MODIFIER_PREFIX)
         );
     }