@litert/typeguard 1.2.0 → 1.3.0-dev.0

package/src/lib/Compiler.ts

@@ -22,8 +22,7 @@ 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>;
 
@@ -45,12 +44,43 @@ 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'),
+            options.traceErrors ? this._lang.varName('failedAsserts') : '',
+            options.traceErrors ? this._lang.varName('tracePrefix') : '',
             this._lang.varName('types'),
             referredTypes
         );
@@ -71,12 +101,28 @@ implements C.ICompiler {
                 source: '',
                 arguments: [{
                     'name': ctx.vName,
-                    'type': 'unknown'
+                    '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
@@ -200,7 +246,7 @@ implements C.ICompiler {
         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) {
 
@@ -210,43 +256,55 @@ implements C.ICompiler {
 
                 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,
@@ -327,7 +385,7 @@ implements C.ICompiler {
 
         const offset = assertRule ? assertRule[1].length + 2 : 2;
 
-        switch ((assertRule?.[1]) ?? rule.substr(0, 2)) {
+        switch ((assertRule?.[1]) ?? rule.slice(0, 2)) {
             case '==':
             case 'equal':
 
@@ -600,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[] = [];
 
@@ -618,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) {
 
@@ -626,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))
@@ -641,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;
@@ -721,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: {
@@ -754,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))
@@ -786,6 +852,7 @@ implements C.ICompiler {
 
         const types = rules.slice();
         let tupleLength = 0;
+        let tupleLengthMin = 0;
 
         while (1) {
 
@@ -822,10 +889,11 @@ implements C.ICompiler {
                     if (type !== 'any') {
 
                         result.push(this._compileModifierLIST(
-                            ctx, type
+                            ctx, type, i
                         ));
                     }
 
+                    tupleLengthMin = tupleLength;
                     tupleLength = -1;
                 }
                 else if (!/^\d+$/.test(dots.slice(3))) {
@@ -836,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;
@@ -864,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++;
             }
 
@@ -874,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'
             ));
         }
 
@@ -903,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]);
@@ -954,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))
@@ -1023,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[] = [];
@@ -1107,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();
         }

package/src/lib/Context.ts

@@ -18,18 +18,18 @@ import * as i from './Internal';
 
 export class Context implements i.IContext {
 
-    public trace: boolean;
-
-    public tracePoint: number;
-
     public vCursor: number;
 
     public stack: i.IContextData[];
 
     public flags: Record<string, i.EFlagValue>;
 
+    public tracePath: string = '';
+
     public constructor(
         public vName: string,
+        public vTraceName: string,
+        public vTracePrefix: string,
         public readonly typeSlotName: string,
         public readonly referredTypes: Record<string, boolean>
     ) {
@@ -38,17 +38,14 @@ export class Context implements i.IContext {
         this.vCursor = 0;
 
         this.flags = {};
-
-        this.tracePoint = 0;
-
-        this.trace = false;
     }
 
     public trap(subjChanged: boolean = false): void {
 
         this.stack.push({
             vName: this.vName,
-            flags: this.flags
+            flags: this.flags,
+            tracePath: this.tracePath,
         });
 
         const prevFlags = this.flags;
@@ -83,7 +80,8 @@ export class Context implements i.IContext {
             throw new Error('Failed to pop stack.');
         }
 
-        this.vName = prev.vName;
         this.flags = prev.flags;
+        this.vName = prev.vName;
+        this.tracePath = prev.tracePath;
     }
 }

package/src/lib/InlineCompiler.ts

@@ -165,7 +165,12 @@ implements IInlineCompiler {
 
         return (new Function(
             info.typeSlotName,
-            `return function(${info.arguments[0].name}) {${soe}
+            `return function(${
+                info.arguments
+                    .map((a) => a.initial ? `${a.name} = ${a.initial}` : a.name)
+                    .join(',')
+            }) {
+                ${soe}
 
                 return ${info.source};
             };`

package/src/lib/Internal.ts

@@ -72,16 +72,18 @@ export enum EFlagValue {
 
 export interface IContextData {
 
+    flags: Record<string, EFlagValue>;
+
     vName: string;
 
-    flags: Record<string, EFlagValue>;
+    tracePath: string;
 }
 
 export interface IContext extends IContextData {
 
-    trace: boolean;
+    vTraceName: string;
 
-    tracePoint: number;
+    vTracePrefix: string;
 
     vCursor: number;
 

package/src/lib/langs/JavaScript.ts

@@ -289,12 +289,14 @@ implements C.ILanguageBuilder {
     }
 
     public forEach(
-        an: string,
-        it: string,
+        arrVar: string,
+        elVar: string,
+        iterVar: string,
         body: string
     ): string {
 
-        return `for (const ${it} of ${an}) {
+        return `for (let ${elVar} = 0; ${elVar} < ${arrVar}.length; ${elVar}++) {
+            const ${iterVar} = ${arrVar}[${elVar}];
             ${body}
         }`;
     }
@@ -424,6 +426,57 @@ implements C.ILanguageBuilder {
             args.join(', ')
         })`;
     }
+
+    public escape(str: string): string {
+
+        return str.replace(/(['"])/g, '\\$1').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+    }
+
+    public stringTemplateVar(varExpr: string): string {
+
+        return `"\${${varExpr}.replace(/(['"])/g, '\\\\$1').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r')}"`;
+    }
+
+    public numberTemplateVar(varExpr: string): string {
+
+        return `\${${varExpr}}`;
+    }
+
+    public addTrace(
+        vTrace: string,
+        vTraceStack: string,
+        path: string,
+        negative: boolean = false
+    ): string {
+
+        if (negative) {
+
+            return `(${vTrace}.push(\`\${${vTraceStack}}${path}\`), true)`;
+        }
+
+        return `(${vTrace}.push(\`\${${vTraceStack}}${path}\`), false)`;
+    }
+
+    public add(a: string | number, b: string | number): string {
+
+        return `${a} + ${b}`;
+    }
+
+    public orAddTrace(
+        expr: string,
+        vTrace: string,
+        vTraceStack: string,
+        path: string,
+        negative: boolean = false
+    ): string {
+
+        if (negative) {
+
+            return `((${expr}) && (${vTrace}.push(\`\${${vTraceStack}}${path}\`), true))`;
+        }
+
+        return `((${expr}) || (${vTrace}.push(\`\${${vTraceStack}}${path}\`), false))`;
+    }
 }
 
 /**

package/src/test/abstracts.ts

@@ -112,6 +112,17 @@ compiler.addPredefinedType<string>(
     }
 );
 
+const compiler2 = TypeGuard.createInlineCompiler();
+
+compiler2.addPredefinedType<string>(
+    'ipv4_address',
+    function(i): i is string {
+        return  typeof i === 'string'
+            && /^[0-9]{1,3}(\.[0-9]{1,3}){3}$/.test(i)
+            && i.split('.').map(x => parseInt(x, 10)).every(x => x >= 0 && x <= 255);
+    }
+);
+
 export function assertItem(input: unknown, expect: boolean | 'throw'): ITestItem {
 
     return {
@@ -150,15 +161,28 @@ export function createTestDefinition(suite: ITestSuite) {
                             assert.throws(() => {
 
                                 compiler.compile<any>({
-                                    'rule': section.rule
+                                    'rule': section.rule,
+                                    traceErrors: true,
+                                });
+                            });
+
+                            assert.throws(() => {
+
+                                compiler2.compile<any>({
+                                    'rule': section.rule,
                                 });
                             });
                         });
                         return;
                     }
 
-                    const check = compiler.compile<any>({
-                        'rule': section.rule
+                    const checkWithTrace = compiler.compile<any>({
+                        'rule': section.rule,
+                        traceErrors: true,
+                    });
+
+                    const checkWithoutTrace = compiler2.compile<any>({
+                        'rule': section.rule,
                     });
 
                     for (const item of section.items.sort((a, b) => a.expect === b.expect ? 0 : (a.expect ? -1 : 1))) {
@@ -170,7 +194,12 @@ export function createTestDefinition(suite: ITestSuite) {
                         }.`, function() {
 
                             assert.equal(
-                                check(item.inputValue),
+                                checkWithTrace(item.inputValue),
+                                item.expect
+                            );
+
+                            assert.equal(
+                                checkWithoutTrace(item.inputValue),
                                 item.expect
                             );
                         });