nirguna 0.1.0

package/packages/printer-wasm/printer/visitors/expression-statement/print-wasm-memory.js

@@ -0,0 +1,31 @@
+import {types} from '@putout/babel';
+
+const {isCallExpression} = types;
+
+export const isWastMemory = (expression) => {
+    if (!isCallExpression(expression))
+        return;
+    
+    const {name} = expression.node.callee;
+    
+    return name === '__ishvara_wasm_memory';
+};
+
+export function printWasmMemory(path, printer) {
+    const {print} = printer;
+    const [first, second] = path.get('arguments');
+    
+    print('(memory ');
+    
+    if (!second) {
+        print(first);
+    } else {
+        print('(export ');
+        print(first);
+        print(')');
+        print.space();
+        print(second);
+    }
+    
+    print(')');
+}

package/packages/printer-wasm/printer/visitors/function-declaration.js

@@ -0,0 +1,91 @@
+import {types} from '@putout/babel';
+import {isNext, isNextParent} from '@putout/printer/is';
+import {printParams} from '../params.js';
+
+const {
+    isAssignmentExpression,
+    isTSModuleBlock,
+    isBlockStatement,
+    isExpressionStatement,
+    isFunctionDeclaration,
+} = types;
+
+export const FunctionDeclaration = {
+    print(path, printer, semantics) {
+        const {print} = printer;
+        const {generator, returnType} = path.node;
+        
+        print('(');
+        print('func');
+        
+        if (!generator) {
+            print(' ');
+        } else {
+            print('*');
+            print.space();
+        }
+        
+        print('$');
+        print('__id');
+        
+        if (path.parentPath.isExportNamedDeclaration()) {
+            print(' ');
+            print('(');
+            print('export ');
+            print('"');
+            print('__id');
+            print('"');
+            print(')');
+            print(' ');
+        }
+        
+        printParams(path, printer, semantics, {
+            braceOpen: '(param ',
+        });
+        
+        if (returnType) {
+            print.space();
+            print('(');
+            print('result ');
+            print('__returnType');
+            print(')');
+        }
+        
+        print('__body');
+        print(')');
+    },
+    afterSatisfy: () => [isNext, isNextParent, isInsideBlockStatement],
+    after(path, {indent, write}) {
+        if (isNextAssign(path) || isNextFunction(path) || isNext(path))
+            indent();
+        
+        write.breakline();
+        //maybe.write.newline(notInsideExportDefaultWithBody(path));
+    },
+};
+
+const isNextFunction = (path) => {
+    const next = path.getNextSibling();
+    return isFunctionDeclaration(next);
+};
+
+const isNextAssign = (path) => {
+    const next = path.getNextSibling();
+    
+    if (!isExpressionStatement(next))
+        return false;
+    
+    return isAssignmentExpression(next.node.expression);
+};
+
+function isInsideBlockStatement(path) {
+    const {parentPath} = path;
+    
+    if (isTSModuleBlock(parentPath.parentPath))
+        return true;
+    
+    if (!isBlockStatement(parentPath))
+        return false;
+    
+    return !path.node.body.body.length;
+}

package/packages/printer-wasm/printer/visitors/identifier.js

@@ -0,0 +1,11 @@
+import {maybeTypeAnnotation} from '../maybe-type-annotation.js';
+
+export const Identifier = maybeTypeAnnotation((path, printer) => {
+    const {write, maybe} = printer;
+    
+    const {node} = path;
+    const {name, optional} = node;
+    
+    write(name);
+    maybe.write(optional, '?');
+});

package/packages/printer-wasm/printer/visitors/if-statement.js

@@ -0,0 +1,128 @@
+import {types} from '@putout/babel';
+import {exists, isInsideIf} from '@putout/printer/is';
+
+const {
+    isBlockStatement,
+    isFunctionDeclaration,
+    isStatement,
+    isReturnStatement,
+} = types;
+
+const isTopLevel = ({parentPath}) => parentPath.parentPath.isProgram();
+
+const isInsideNestedBody = ({parentPath}) => {
+    if (parentPath.type !== 'BlockStatement')
+        return false;
+    
+    return parentPath.parentPath.type === 'BlockStatement';
+};
+
+const isEmptyBody = (path) => !path.node.body.length;
+
+const isLastEmptyInsideBody = (path) => {
+    const {parentPath} = path;
+    
+    if (!isBlockStatement(parentPath))
+        return false;
+    
+    if (!isBlockStatement(path.node.consequent))
+        return false;
+    
+    if (path.node.consequent.body.length)
+        return false;
+    
+    return isFunctionDeclaration(path.parentPath.parentPath);
+};
+
+export const IfStatement = (path, {indent, print, maybe, write, traverse}) => {
+    const {parentPath} = path;
+    const partOfAlternate = parentPath.get('alternate');
+    
+    if (path !== partOfAlternate)
+        indent();
+    
+    print('(if');
+    
+    if (path.node.test.typeArguments) {
+        print.space();
+        print('(result ');
+        print(path.get('test.typeArguments.params.0.typeName'));
+        print(')');
+    }
+    
+    indent.inc();
+    print.breakline();
+    
+    print('__test');
+    print.breakline();
+    print('(then');
+    
+    const consequent = path.get('consequent');
+    const alternate = path.get('alternate');
+    const isConsequentBlock = consequent.isBlockStatement();
+    const isVar = consequent.isVariableDeclaration();
+    
+    if (isConsequentBlock) {
+        print.space();
+        print(consequent);
+        
+        if (isInsideIf(path.parentPath) || isInsideNestedBody(path))
+            maybe.print.newline(isEmptyBody(consequent));
+    } else {
+        const isRet = isReturnStatement(consequent);
+        print.newline();
+        indent.inc();
+        maybe.indent(!isRet);
+        print(consequent);
+        indent.dec();
+        maybe.print.newline(!isRet);
+    }
+    
+    indent();
+    print(')');
+    print.newline();
+    
+    if (alternate.isBlockStatement()) {
+        write.space();
+        write('(else');
+        write.space();
+        traverse(alternate);
+    } else if (alternate.isIfStatement()) {
+        if (alternate.get('consequent').isBlockStatement())
+            write.space();
+        else
+            indent();
+        
+        write('(else ');
+        traverse(alternate);
+    } else if (exists(alternate)) {
+        maybe.write.newline(isVar);
+        maybe.indent(!isConsequentBlock);
+        maybe.write.space(isConsequentBlock);
+        write('(else');
+        write.splitter();
+        indent.inc();
+        
+        const isRet = isReturnStatement(alternate);
+        maybe.indent(!isRet);
+        traverse(alternate);
+        maybe.write.newline(!isRet);
+        indent.dec();
+        indent();
+        write(')');
+        write.newline();
+    }
+    
+    const nextPath = path.parentPath.getNextSibling();
+    
+    if (path === partOfAlternate && !isTopLevel(path) && !isStatement(nextPath))
+        print.newline();
+    
+    if (isLastEmptyInsideBody(path))
+        print.newline();
+    
+    indent.dec();
+    indent();
+    print(')');
+    print.newline();
+};

package/packages/printer-wasm/printer/visitors/program.js

@@ -0,0 +1,26 @@
+import {hasCoupleTrailingComments} from '@putout/printer/is';
+
+export const Program = (path, printer) => {
+    const {body} = path.node;
+    const {
+        traverse,
+        write,
+        indent,
+    } = printer;
+    
+    traverse(path.get('interpreter'));
+    write('(');
+    write('module');
+    indent.inc();
+    write.breakline();
+    
+    path.get('body').forEach(traverse);
+    indent.dec();
+    write.newline();
+    write(')');
+    
+    if (body.length && hasCoupleTrailingComments(body.at(-1)))
+        return;
+    
+    write.endOfFile();
+};

package/packages/printer-wasm/printer/visitors/return.js

@@ -0,0 +1,16 @@
+export const ReturnStatement = (path, printer) => {
+    const {
+        indent,
+        print,
+        maybe,
+    } = printer;
+    
+    indent();
+    print('(');
+    print('return');
+    maybe.print.space(path.node.argument);
+    
+    print('__argument');
+    print(')');
+    print.newline();
+};

package/packages/printer-wasm/printer.js

@@ -0,0 +1,10 @@
+import {parse} from 'putout';
+import * as printer from './printer/printer.js';
+
+export const print = (source) => {
+    const ast = parse(source, {
+        isTS: true,
+    });
+    
+    return printer.print(ast);
+};

package/packages/test-wasm/test.js

@@ -0,0 +1,45 @@
+const {entries} = Object;
+
+export const prepare = (wast) => {
+    const result = {};
+    let stack = [];
+    let imports = [];
+    
+    for (const [name, value] of entries(wast)) {
+        if (name === 'stack') {
+            stack = value;
+            continue;
+        }
+        
+        if (name === 'imports') {
+            imports = value;
+            continue;
+        }
+        
+        result[name] = (...args) => {
+            value(...args);
+            
+            return stack[0];
+        };
+    }
+    
+    result.declareImport = (module, name, override) => {
+        for (const [i, [currentModule, currentName]] of imports.entries()) {
+            if (module === currentModule && name === currentName) {
+                imports[i].push(override);
+                return;
+            }
+        }
+    };
+    
+    result.undeclareImport = (module, name) => {
+        for (const [i, [currentModule, currentName]] of imports.entries()) {
+            if (module === currentModule && name === currentName) {
+                imports[i].pop();
+                return;
+            }
+        }
+    };
+    
+    return result;
+};

package/packages/transformer-fasm/transformer.js

@@ -0,0 +1,70 @@
+import {readFileSync as _readFileSync} from 'node:fs';
+import putout from 'putout';
+import * as removeUselessOperand from '@putout/plugin-remove-useless-operand';
+import * as removeNestedBlocks from '@putout/plugin-remove-nested-blocks';
+import * as fasm from '@nirguna/plugin-fasm';
+import * as ishvara from '@nirguna/plugin-ishvara';
+import * as bundler from '@nirguna/plugin-bandler-fasm';
+
+const defaultConfig = {
+    rules: {},
+    plugins: [],
+};
+
+const parseConfig = (config) => ({
+    ...defaultConfig,
+    ...config,
+});
+
+export const transform = (source, config) => {
+    const {
+        debug,
+        plugins,
+        rules,
+        readFileSync = _readFileSync,
+    } = parseConfig(config);
+    
+    const variables = [];
+    const functions = [];
+    
+    const {code: bundled} = putout(source, {
+        isTS: true,
+        rules: {
+            'ishvara/bundler-fasm/apply-debug': ['on', {
+                debug,
+                count: 0,
+                variables,
+                functions,
+            }],
+            'ishvara/bundler-fasm/replace-section-data-with-let': ['on', {
+                variables,
+            }],
+            'ishvara/bundler-fasm/replace-section-code-with-functions': ['on', {
+                functions,
+            }],
+        },
+        plugins: [
+            ['ishvara/bundler-fasm', bundler],
+        ],
+    });
+    
+    const {code, places} = putout(bundled, {
+        fixCount: 5,
+        isTS: true,
+        rules: {
+            ...rules,
+            'ishvara/fasm/apply-include': ['on', {
+                readFileSync,
+            }],
+        },
+        plugins: [
+            ...plugins,
+            ['remove-useless-operand', removeUselessOperand],
+            ['remove-nested-blocks', removeNestedBlocks],
+            ['ishvara/ishvara', ishvara],
+            ['ishvara/fasm', fasm],
+        ],
+    });
+    
+    return [code, places];
+};

package/packages/transformer-wasm/transformer.js

@@ -0,0 +1,20 @@
+import putout from 'putout';
+import * as removeNestedBlocks from '@putout/plugin-remove-nested-blocks';
+import * as esm from '@putout/plugin-esm';
+import * as ishvara from '@nirguna/plugin-ishvara';
+import * as wasm from '@nirguna/plugin-wasm';
+
+export const transform = (source) => {
+    const {code, places} = putout(source, {
+        fix: true,
+        isTS: true,
+        plugins: [
+            ['ishvara/wasm', wasm],
+            ['ishvara/ishvara', ishvara],
+            ['esm', esm],
+            ['remove-nested-blocks', removeNestedBlocks],
+        ],
+    });
+    
+    return [code, places];
+};

package/packages/translator-fasm/dump.js

@@ -0,0 +1,68 @@
+import {
+    Decoder,
+    DecoderOptions,
+    Formatter,
+    FormatterSyntax,
+} from 'iced-x86';
+
+function parseBitness(source) {
+    if (source.startsWith('use32'))
+        return 32;
+    
+    return 16;
+}
+
+export const dump = (source, binary) => {
+    const exampleRip = 0x0000000000007c00n;
+    const hexBytesColumnByteLength = 10;
+    const bitness = parseBitness(source);
+    
+    const decoder = new Decoder(bitness, binary, DecoderOptions.None);
+    
+    decoder.ip = exampleRip;
+    // This decodes all bytes. There's also `decode()` which decodes the next instruction,
+    // `decodeInstructions(count)` which decodes `count` instructions and `decodeOut(instruction)`
+    // which overwrites an existing instruction.
+    const instructions = decoder.decodeAll();
+    
+    // Create a nasm formatter. It supports: Masm, Nasm, Gas (AT&T) and Intel (XED).
+    // There's also `FastFormatter` which uses less code (smaller wasm files).
+    //     const formatter = new FastFormatter();
+    const formatter = new Formatter(FormatterSyntax.Intel);
+    
+    // Change some options, there are many more
+    formatter.digitSeparator = '`';
+    formatter.firstOperandCharIndex = 10;
+    // Format the instructions
+    
+    const output = instructions.map((instruction) => {
+        // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF     lea       rbp,[rsp-100h]"
+        let line = instruction.ip.toString(16);
+        
+        line += ' ';
+        const startIndex = Number(instruction.ip - exampleRip);
+        
+        for (const b of binary.slice(startIndex, startIndex + instruction.length)) {
+            line += ('0' + b.toString(16))
+                .substr(-2)
+                .toUpperCase();
+        }
+        
+        for (let i = instruction.length; i < hexBytesColumnByteLength; i++)
+            line += '  ';
+        
+        line += ' ';
+        line += formatter.format(instruction);
+        
+        return line;
+    });
+    
+    // Free wasm memory
+    for (const instruction of instructions)
+        instruction.free();
+    
+    formatter.free();
+    decoder.free();
+    
+    return output.join('\n');
+};

package/packages/translator-fasm/translator.js

@@ -0,0 +1,15 @@
+import * as fasm from 'fasm.js';
+import {dump} from './dump.js';
+
+export const translate = async (source, options = {}) => {
+    const {type} = options;
+    const [binary, places] = await fasm.translate(source);
+    
+    if (type === 'dump')
+        return [
+            dump(source, binary),
+            [],
+        ];
+    
+    return [binary, places];
+};

package/packages/translator-wasm/translator.js

@@ -0,0 +1,51 @@
+import createWabt from 'wabt';
+import {tryCatch} from 'try-catch';
+
+export const translate = async (wast, options = {}) => {
+    const {name = 'ishvara.wast', type} = options;
+    
+    const {parseWat} = await createWabt();
+    const [error, parsedWat] = tryCatch(parseWat, name, wast);
+    
+    if (error)
+        return [null, toPlaces(name, error)];
+    
+    const {log, buffer} = parsedWat.toBinary({
+        log: type === 'dump',
+    });
+    
+    return [
+        log || buffer,
+        [],
+    ];
+};
+
+function toPlaces(name, error) {
+    const [, first] = error.message.split('\n');
+    
+    const list = first
+        .replace(`${name}�`, '')
+        .split(':');
+    
+    list.shift();
+    
+    const [line, column] = list;
+    
+    list.shift();
+    list.shift();
+    list.shift();
+    
+    const messageRaw = list
+        .join(':')
+        .slice(1);
+    
+    const message = messageRaw[0].toUpperCase() + messageRaw.slice(1);
+    
+    return [{
+        message,
+        position: {
+            line: Number(line),
+            column: Number(column),
+        },
+    }];
+}