@informalsystems/quint/dist/test/ir/IRTransformer.test.js

Core tool for the Quint specification language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const mocha_1 = require("mocha");
const chai_1 = require("chai");
const ir_1 = require("../builders/ir");
const quintIr_1 = require("../../src/ir/quintIr");
const IRprinting_1 = require("../../src/ir/IRprinting");
const IRTransformer_1 = require("../../src/ir/IRTransformer");
const quintModule = (0, ir_1.buildModuleWithDecls)([
    'var a: int',
    'const B: int',
    'type MY_TYPE = int',
    'assume _ = N > 1',
    'import M.*',
    'import A(x = "rainbow") as A1',
    'val f = S.filter(x => x + 1)',
    'def l = val x = false { x }',
]);
(0, mocha_1.describe)('enterExpr', () => {
    (0, mocha_1.it)('transforms expressions', () => {
        class TestTransformer {
            enterExpr(expr) {
                return { kind: 'int', value: 42n, id: expr.id };
            }
        }
        const transformer = new TestTransformer();
        const result = (0, IRTransformer_1.transformModule)(transformer, quintModule);
        const expectedModule = (0, ir_1.buildModuleWithDecls)([
            'var a: int',
            'const B: int',
            'type MY_TYPE = int',
            'assume _ = 42',
            'import M.*',
            'import A(x = 42) as A1',
            'val f = 42',
            'def l = 42',
        ]);
        chai_1.assert.deepEqual((0, IRprinting_1.moduleToString)(result), (0, IRprinting_1.moduleToString)(expectedModule));
    });
    (0, mocha_1.it)('transforms parameter type annotations', () => {
        class TestTransformer {
            exitType(_) {
                return { kind: 'var', name: 'trans' };
            }
        }
        const transformer = new TestTransformer();
        const m = (0, ir_1.buildModuleWithDecls)(['def foo(x: int, b: int, c: str): int = 42']);
        const transformedDecl = (0, IRTransformer_1.transformModule)(transformer, m).declarations[0];
        (0, chai_1.assert)(transformedDecl.kind === 'def');
        (0, chai_1.assert)(transformedDecl.expr.kind === 'lambda');
        transformedDecl.expr.params.forEach(p => {
            (0, chai_1.assert)(p.typeAnnotation);
            chai_1.assert.deepEqual(p.typeAnnotation, { kind: 'var', name: 'trans' });
        });
    });
});
(0, mocha_1.describe)('enterDecl', () => {
    (0, mocha_1.it)('transforms declarations', () => {
        class TestTransformer {
            enterDecl(decl) {
                if ((0, quintIr_1.isDef)(decl)) {
                    return { ...decl, name: 'NewName' };
                }
                else {
                    return { ...decl, protoName: 'NewModuleName' };
                }
            }
        }
        const transformer = new TestTransformer();
        const result = (0, IRTransformer_1.transformModule)(transformer, quintModule);
        const expectedModule = (0, ir_1.buildModuleWithDecls)([
            'var NewName: int',
            'const NewName: int',
            'type NewName = int',
            'assume NewName = N > 1',
            'import NewModuleName.*',
            'import NewModuleName(x = "rainbow") as A1',
            'val NewName = S.filter(x => x + 1)',
            'def NewName = val x = false { x }',
        ]);
        chai_1.assert.deepEqual((0, IRprinting_1.moduleToString)(result), (0, IRprinting_1.moduleToString)(expectedModule));
    });
});
(0, mocha_1.describe)('enterDef', () => {
    (0, mocha_1.it)('transforms definitions', () => {
        class TestTransformer {
            enterDef(def) {
                return { ...def, name: 'NewName' };
            }
        }
        const transformer = new TestTransformer();
        const result = (0, IRTransformer_1.transformModule)(transformer, quintModule);
        const expectedModule = (0, ir_1.buildModuleWithDecls)([
            'var NewName: int',
            'const NewName: int',
            'type NewName = int',
            'assume NewName = N > 1',
            'import M.*',
            'import A(x = "rainbow") as A1',
            'val NewName = S.filter(x => x + 1)',
            'def NewName = val NewName = false { x }',
        ]);
        chai_1.assert.deepEqual((0, IRprinting_1.moduleToString)(result), (0, IRprinting_1.moduleToString)(expectedModule));
    });
});
(0, mocha_1.describe)('enterType', () => {
    (0, mocha_1.it)('transforms types', () => {
        class TestTransformer {
            enterType(type) {
                return { kind: 'bool', id: type.id };
            }
        }
        const transformer = new TestTransformer();
        const result = (0, IRTransformer_1.transformModule)(transformer, quintModule);
        const expectedModule = (0, ir_1.buildModuleWithDecls)([
            'var a: bool',
            'const B: bool',
            'type MY_TYPE = bool',
            'assume _ = N > 1',
            'import M.*',
            'import A(x = "rainbow") as A1',
            'val f = S.filter(x => x + 1)',
            'def l = val x = false { x }',
        ]);
        chai_1.assert.deepEqual((0, IRprinting_1.moduleToString)(result), (0, IRprinting_1.moduleToString)(expectedModule));
    });
});
(0, mocha_1.describe)('enterConcreteRow', () => {
    (0, mocha_1.it)('transforms rows', () => {
        class TestTransformer {
            enterConcreteRow(row) {
                return { ...row, fields: [{ fieldName: 'newField', fieldType: { kind: 'int' } }] };
            }
        }
        const quintModuleWithRow = (0, ir_1.buildModuleWithDecls)(['type T = { x: int, y: bool }']);
        const transformer = new TestTransformer();
        const result = (0, IRTransformer_1.transformModule)(transformer, quintModuleWithRow);
        const expectedModule = (0, ir_1.buildModuleWithDecls)(['type T = { newField: int }']);
        chai_1.assert.deepEqual((0, IRprinting_1.moduleToString)(result), (0, IRprinting_1.moduleToString)(expectedModule));
    });
});
//# sourceMappingURL=IRTransformer.test.js.map