@litert/typeguard 1.0.1 → 1.3.0-dev.0

package/lib/Compiler.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * 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.
@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompiler = void 0;
 const I = require("./Internal");
 const M = require("./Modifiers");
 const Context_1 = require("./Context");
@@ -34,23 +35,48 @@ class Compiler {
         }
         return null;
     }
+    _addTrace(ctx) {
+        if (!ctx.vTraceName) {
+            return this._lang.literalFalse;
+        }
+        return this._lang.addTrace(ctx.vTraceName, ctx.vTracePrefix, ctx.tracePath);
+    }
+    _addTraceOr(ctx, expr, subPath = '') {
+        if (!ctx.vTraceName) {
+            return expr;
+        }
+        return this._lang.orAddTrace(expr, ctx.vTraceName, ctx.vTracePrefix, `${ctx.tracePath}${subPath}`);
+    }
     compile(options) {
         const referredTypes = {};
-        const ctx = new Context_1.Context(this._lang.varName("entry"), this._lang.varName("types"), referredTypes);
+        const ctx = new Context_1.Context(this._lang.varName('entry'), options.traceErrors ? this._lang.varName('failedAsserts') : '', options.traceErrors ? this._lang.varName('tracePrefix') : '', this._lang.varName('types'), referredTypes);
         if (options.name) {
             this._compile(ctx, [M.TYPE, options.name, options.rule]);
             return this._defTypes[options.name];
         }
         else {
             const ret = {
-                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);
             ret.referredTypes = Object.keys(ctx.referredTypes);
             return ret;
@@ -58,9 +84,9 @@ class Compiler {
     }
     _compile(ctx, rules) {
         switch (typeof rules) {
-            case "string":
+            case 'string':
                 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)),
@@ -68,7 +94,7 @@ class Compiler {
                     ]);
                 }
                 return this._lang.eq(ctx.vName, this._lang.literal(rules));
-            case "number":
+            case 'number':
                 if (ctx.flags[I.EFlags.FROM_STRING]) {
                     return this._lang.or([
                         this._lang.eq(ctx.vName, this._lang.literal(rules)),
@@ -76,7 +102,7 @@ class Compiler {
                     ]);
                 }
                 return this._lang.eq(ctx.vName, this._lang.literal(rules));
-            case "object":
+            case 'object':
                 if (Array.isArray(rules)) {
                     return this._compileModifiedRule(ctx, rules);
                 }
@@ -84,16 +110,18 @@ class Compiler {
                     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.eq(ctx.vName, this._lang.literal('null'))
                         ]);
                     }
                     return this._lang.isNull(ctx.vName, true);
                 }
                 return this._compileStructuredRule(ctx, rules);
-            case "undefined":
+            case 'undefined':
                 return this._lang.isUndefined(ctx.vName, true);
+            default:
+                break;
         }
-        throw new TypeError("Unknwn rules.");
+        throw new TypeError('Unknwn rules.');
     }
     _compileStringRule(ctx, rule) {
         const strAssert = this._useStringAssert(ctx, rule);
@@ -103,55 +131,67 @@ class Compiler {
                 strAssert
             ]);
         }
-        if (rule[0] === I.IMPLICIT_SYMBOL) {
+        if (rule.startsWith(I.IMPLICIT_SYMBOL)) {
             return this._lang.or([
                 this._builtInTypes.compile(B.VOID, ctx, []),
                 this._compileStringRule(ctx, rule.slice(1))
             ]);
         }
-        if (rule[0] === I.NEGATIVE_SYMBOL) {
+        if (rule.startsWith(I.NEGATIVE_SYMBOL)) {
             return this._lang.not(this._compileStringRule(ctx, rule.slice(1)));
         }
-        let regResult;
+        let regResult = /\[\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,
@@ -159,9 +199,10 @@ class Compiler {
                 ])
             ]);
         }
-        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:
          *
@@ -170,14 +211,14 @@ class Compiler {
          * - `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((x) => parseFloat(x.trim()));
+                const args = regResult[2].slice(1, -1).trim().split(',').map((x) => parseFloat(x.trim()));
                 return this._builtInTypes.compile(regResult[1], ctx, args);
             }
             return this._builtInTypes.compile(regResult[1], ctx, []);
         }
-        if (rule[0] === I.FILTER_PREFIX) {
+        if (rule.startsWith(I.FILTER_PREFIX)) {
             return this._filters.compile(rule, ctx);
         }
         throw new TypeError(`Unknown type "${rule}".`);
@@ -188,64 +229,65 @@ class Compiler {
         return this._lang.call(this._lang.fieldIndex(ctx.typeSlotName, this._lang.literal(typeName)), ctx.vName);
     }
     _useStringAssert(ctx, rule) {
-        const assertRule = rule.match(/^:([-\w]+):/);
+        var _a;
+        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 ((_a = (assertRule === null || assertRule === void 0 ? void 0 : assertRule[1])) !== null && _a !== void 0 ? _a : rule.slice(0, 2)) {
+            case '==':
+            case 'equal':
                 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()));
-            case "!=":
-            case "not-equal":
+            case '!=':
+            case 'not-equal':
                 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()));
-            case "~=":
-            case "match":
+            case '~=':
+            case 'match':
                 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)));
-            case "?=":
-            case "include":
+            case '?=':
+            case 'include':
                 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))));
-            case "*=":
-            case "include-i":
+            case '*=':
+            case 'include-i':
                 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())));
-            case "^=":
-            case "start-with":
+            case '^=':
+            case 'start-with':
                 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()));
-            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))));
-            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())));
-            case "$=":
-            case "end-with":
+            case '$=':
+            case 'end-with':
                 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()));
-            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))));
-            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())));
             default:
-                if (rule.startsWith("=")) {
+                if (rule.startsWith('=')) {
                     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));
                 }
         }
@@ -253,12 +295,12 @@ class Compiler {
     }
     _compileModifiedRule(ctx, rules) {
         if (!rules.length) {
-            throw new TypeError(`Unknwon type "[]".`);
+            throw new TypeError('Unknwon type "[]".');
         }
         /**
          * By default, use OR modifier.
          */
-        if (typeof rules[0] !== "string" ||
+        if (typeof rules[0] !== 'string' ||
             !rules[0].startsWith(I.MODIFIER_PREFIX)) {
             if (rules.length === 1) {
                 return this._compile(ctx, rules[0]);
@@ -313,7 +355,7 @@ class Compiler {
         return result;
     }
     _compileModifierOR(ctx, rules) {
-        let result = [];
+        const result = [];
         for (const r of rules) {
             ctx.trap();
             result.push(this._compile(ctx, r));
@@ -324,7 +366,7 @@ class Compiler {
     _compileModifierAND(ctx, rules) {
         return this._lang.and(rules.map((rule) => this._compile(ctx, rule)));
     }
-    _compileModifierLIST(ctx, rules) {
+    _compileModifierLIST(ctx, rules, traceOffset = 0) {
         const result = [];
         if (!ctx.flags[I.EFlags.ARRAY]) {
             result.push(this._lang.isArray(ctx.vName, true));
@@ -334,16 +376,18 @@ class Compiler {
         const CLOSURE_ARG = ctx.vName;
         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) {
             result.push(this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                this._lang.forEach(CLOSURE_PARAM, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._lang.literal(false)))),
+                this._lang.forEach(CLOSURE_PARAM, vIter, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._addTrace(ctx)))),
                 this._lang.returnValue(this._lang.literal(true))
             ])));
         }
         ctx.untrap();
         return this._lang.and(result);
     }
-    _compileModifierARRAY(ctx, rules) {
+    _compileModifierARRAY(ctx, rules, traceOffset = 0) {
         let a = 0;
         let b = -1;
         if (Number.isInteger(rules[0]) && rules[0] >= 0) {
@@ -389,6 +433,8 @@ class Compiler {
         const CLOSURE_ARG = ctx.vName;
         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: {
                 result.push(this._lang.eq(this._lang.arrayLength(CLOSURE_ARG), a));
@@ -405,7 +451,7 @@ class Compiler {
         }
         if (rules[1] !== B.ANY) {
             result.push(this._lang.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                this._lang.forEach(CLOSURE_PARAM, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules.slice(1))), this._lang.returnValue(this._lang.literal(false)))),
+                this._lang.forEach(CLOSURE_PARAM, vIter, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules.slice(1))), this._lang.returnValue(this._addTrace(ctx)))),
                 this._lang.returnValue(this._lang.literal(true))
             ])));
         }
@@ -423,18 +469,19 @@ class Compiler {
         let i = 0;
         const types = rules.slice();
         let tupleLength = 0;
+        let tupleLengthMin = 0;
         while (1) {
             type = types.shift();
             if (type === undefined) {
                 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.
                      */
@@ -442,9 +489,10 @@ class Compiler {
                         throw new TypeError(`Invalid syntax for tuple: ${JSON.stringify(rules)}`);
                     }
                     ctx.vName = this._lang.arraySlice(ctx.vName, i);
-                    if (type !== "any") {
-                        result.push(this._compileModifierLIST(ctx, type));
+                    if (type !== 'any') {
+                        result.push(this._compileModifierLIST(ctx, type, i));
                     }
+                    tupleLengthMin = tupleLength;
                     tupleLength = -1;
                 }
                 else if (!/^\d+$/.test(dots.slice(3))) {
@@ -452,16 +500,18 @@ class Compiler {
                 }
                 else {
                     const length = parseInt(dots.slice(3));
-                    if (length <= 3) {
+                    if (length === 0) {
+                        throw new TypeError(`Invalid syntax for tuple: ${dots}`);
+                    }
+                    else if (length === 1) {
                         const vName = ctx.vName;
-                        for (let j = 0; j < length; j++) {
-                            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]));
+                        result.push(this._compileModifierARRAY(ctx, [length, type], i));
                         i += length;
                     }
                     tupleLength += length;
@@ -469,19 +519,23 @@ class Compiler {
             }
             else {
                 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++;
             }
             ctx.untrap();
         }
         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'));
         }
         return this._lang.and(result);
     }
     _validateTypeName(name) {
-        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)} for a pre-defined type.`);
         }
     }
@@ -491,7 +545,8 @@ class Compiler {
             throw new Error(`Dplicated name ${JSON.stringify(rules[0])} for a pre-defined type.`);
         }
         this._defTypes[rules[0]] = this.compile({
-            rule: rules.slice(1)
+            rule: rules.slice(1),
+            traceErrors: !!ctx.vTraceName
         });
         return this._usePredefinedType(ctx, rules[0]);
     }
@@ -520,14 +575,15 @@ class Compiler {
             rules = rules[0];
         }
         ctx.trap(true);
-        const CLOSURE_ARG = ctx.vName;
-        const CLOSURE_PARAM = this._lang.varName(ctx.vCursor++);
-        const FOR_IN_KEY = this._lang.varName(ctx.vCursor++);
+        const vCArg = ctx.vName;
+        const vCParam = 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.closure([CLOSURE_PARAM], [CLOSURE_ARG], this._lang.series([
-                this._lang.forIn(CLOSURE_PARAM, FOR_IN_KEY, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._lang.literal(false)))),
+            this._lang.isStrucutre(vCArg, true),
+            this._lang.closure([vCParam], [vCArg], this._lang.series([
+                this._lang.forIn(vCParam, vKey, ctx.vName, this._lang.ifThen(this._lang.not(this._compile(ctx, rules)), this._lang.returnValue(this._addTrace(ctx)))),
                 this._lang.returnValue(this._lang.literal(true))
             ]))
         ]);
@@ -538,15 +594,15 @@ class Compiler {
         if (rules.length < 2 || !Array.isArray(rules[0])) {
             throw new SyntaxError(`Invalid dict ${JSON.stringify(rules)}.`);
         }
-        let tmp = {};
+        const tmp = {};
         const id = `${Date.now()}${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}`;
         this._compileModifierTYPE(ctx, [
             this._lang.varName(id),
             rules.slice(1)
         ]);
         const type = `${I.PREDEF_TYPE_SYMBOL}${this._lang.varName(id)}`;
-        for (let key of rules[0]) {
-            if (typeof key !== "string") {
+        for (const key of rules[0]) {
+            if (typeof key !== 'string') {
                 throw new SyntaxError(`Invalid key ${JSON.stringify(key)} for dict.`);
             }
             tmp[key] = type;
@@ -556,7 +612,7 @@ class Compiler {
     _compileSimpleStructure(ctx, rules) {
         const strict = !!ctx.flags[I.EFlags.STRICT];
         const result = [
-            this._lang.isStrucutre(ctx.vName, true)
+            this._addTraceOr(ctx, this._lang.isStrucutre(ctx.vName, true), '!object')
         ];
         const keys = [];
         for (let k in rules) {
@@ -584,7 +640,7 @@ class Compiler {
                 rule = [M.EQUAL, rule];
             }
             else {
-                const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
+                const matchResult = I.KEY_ARRAY_SUFFIX.exec(k);
                 if (matchResult) {
                     k = k.slice(0, matchResult.index);
                     if (matchResult[3]) {
@@ -615,7 +671,8 @@ class Compiler {
             }
             keys.push(k);
             ctx.vName = this._lang.fieldIndex(ctx.vName, this._lang.literal(k));
-            result.push(this._compile(ctx, rule));
+            ctx.tracePath = `${ctx.tracePath}[${this._lang.literal(k)}]`;
+            result.push(this._addTraceOr(ctx, this._compile(ctx, rule)));
             ctx.untrap();
         }
         if (strict && keys.length) {
@@ -626,7 +683,7 @@ class Compiler {
     _compileStructuredRule(ctx, rules) {
         const mapSymbol = Object.keys(rules).filter((x) => x.startsWith(M.MAP));
         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) {
             return this._compileSimpleStructure(ctx, rules);
@@ -666,7 +723,7 @@ class Compiler {
                 rule = [M.EQUAL, rule];
             }
             else {
-                const matchResult = k.match(I.KEY_ARRAY_SUFFIX);
+                const matchResult = I.KEY_ARRAY_SUFFIX.exec(k);
                 if (matchResult) {
                     k = k.slice(0, matchResult.index);
                     if (matchResult[3]) {
@@ -718,7 +775,7 @@ class Compiler {
     }
     _isOrRule(rule) {
         return Array.isArray(rule) && (rule[0] === M.OR ||
-            typeof rule[0] !== "string" ||
+            typeof rule[0] !== 'string' ||
             !rule[0].startsWith(I.MODIFIER_PREFIX));
     }
 }