nirguna 0.1.0

package/packages/printer-fasm/printer/visitors/assignment-expression.js

@@ -0,0 +1,47 @@
+import {visitors} from '@putout/printer';
+import {types} from '@putout/babel';
+
+const {isMemberExpression} = types;
+
+export const AssignmentExpression = (path, printer, semantics) => {
+    const left = path.get('left');
+    const right = path.get('right');
+    
+    if (isMemberExpression(left) && left.node.computed) {
+        const {write, traverse} = printer;
+        const object = path.get('left.object');
+        const property = path.get('left.property');
+        
+        write('mov ');
+        write('[');
+        traverse(object);
+        write(':');
+        traverse(property);
+        write(']');
+        write(',');
+        write.space();
+        traverse(right);
+        
+        return;
+    }
+    
+    if (isMemberExpression(right) && right.node.computed) {
+        const {write, traverse} = printer;
+        const object = path.get('right.object');
+        const property = path.get('right.property');
+        
+        write('mov ');
+        traverse(left);
+        write(',');
+        write.space();
+        write('[');
+        traverse(object);
+        write(':');
+        traverse(property);
+        write(']');
+        
+        return;
+    }
+    
+    return visitors.AssignmentExpression(path, printer, semantics);
+};

package/packages/printer-fasm/printer/visitors/block-statement.js

@@ -0,0 +1,7 @@
+export const BlockStatement = (path, {traverse}) => {
+    const body = path.get('body');
+    
+    for (const element of body) {
+        traverse(element);
+    }
+};

package/packages/printer-fasm/printer/visitors/call-expression.js

@@ -0,0 +1,56 @@
+const {isArray} = Array;
+
+const parseArgs = (path) => {
+    const argsPath = path.get('arguments');
+    
+    if (!isArray(argsPath))
+        return [];
+    
+    return argsPath;
+};
+
+export function CallExpression(path, {indent, print, maybe, traverse}) {
+    const args = parseArgs(path);
+    const isParentCall = tooLong(args) && path.parentPath.isCallExpression();
+    
+    const callee = path.get('callee');
+    
+    traverse(callee);
+    
+    maybe.print.space(args.length);
+    
+    const n = args.length - 1;
+    
+    maybe.indent.inc(isParentCall);
+    
+    for (const [i, arg] of args.entries()) {
+        const isObject = arg.isObjectExpression();
+        
+        if (isParentCall && !isObject && n)
+            print.breakline();
+        
+        print(arg);
+        
+        if (isParentCall && n) {
+            print(',');
+            continue;
+        }
+        
+        if (i < n)
+            print(', ');
+    }
+    
+    if (isParentCall) {
+        indent.dec();
+        maybe.print.breakline(n);
+    }
+}
+
+function tooLong(args) {
+    for (const arg of args) {
+        if (arg.isIdentifier() && arg.node.name.length > 10)
+            return true;
+    }
+    
+    return false;
+}

package/packages/printer-fasm/printer/visitors/expression-statement/expression-statement.js

@@ -0,0 +1,34 @@
+import {isNext, exists} from '@putout/printer/is';
+import {isJmpFar, printJmpFar} from './print-jmp-far.js';
+import {isInOut, printInOut} from './print-in-out.js';
+
+export const ExpressionStatement = (path, printer) => {
+    const {
+        maybe,
+        print,
+        indent,
+        traverse,
+    } = printer;
+    
+    const expression = path.get('expression');
+    
+    if (isJmpFar(expression)) {
+        printJmpFar(expression, printer);
+        maybe.print.breakline(isNext(path));
+        
+        return;
+    }
+    
+    if (isInOut(expression)) {
+        printInOut(expression, printer);
+        print.breakline();
+        
+        return;
+    }
+    
+    indent();
+    traverse(expression);
+    
+    const next = path.getNextSibling();
+    maybe.print.newline(exists(next));
+};

package/packages/printer-fasm/printer/visitors/expression-statement/print-in-out.js

@@ -0,0 +1,37 @@
+import {types} from '@putout/babel';
+
+const {
+    isCallExpression,
+    isMemberExpression,
+} = types;
+
+export const isInOut = (expression) => {
+    if (!isCallExpression(expression))
+        return false;
+    
+    const {callee} = expression.node;
+    
+    if (!isMemberExpression(callee))
+        return false;
+    
+    const {object, property} = callee;
+    
+    if (object.name !== 'io')
+        return false;
+    
+    return /^(in|out)$/.test(property.name);
+};
+
+export function printInOut(path, printer) {
+    const {print} = printer;
+    const callee = path.get('callee');
+    const property = callee.get('property');
+    
+    print(property);
+    print(' ');
+    const [arg1, arg2] = path.get('arguments');
+    
+    print(arg1);
+    print(', ');
+    print(arg2);
+}

package/packages/printer-fasm/printer/visitors/expression-statement/print-jmp-far.js

@@ -0,0 +1,30 @@
+import {types} from '@putout/babel';
+
+const {
+    isCallExpression,
+    isMemberExpression,
+} = types;
+
+export const isJmpFar = (expression) => {
+    if (!isCallExpression(expression))
+        return false;
+    
+    const {callee} = expression.node;
+    
+    if (!isMemberExpression(callee))
+        return false;
+    
+    const {object, property} = callee;
+    
+    return object.name === 'jmp' && property.name === 'far';
+};
+
+export function printJmpFar(path, printer) {
+    const {print} = printer;
+    const callee = path.get('callee');
+    const [first] = path.node.arguments;
+    
+    print(callee);
+    print(' ');
+    print(first.value);
+}

package/packages/printer-fasm/printer/visitors/labeled-statement.js

@@ -0,0 +1,14 @@
+import {exists} from '@putout/printer/is';
+
+export const LabeledStatement = (path, {print, maybe}) => {
+    const prev = path.getPrevSibling();
+    const next = path.getNextSibling();
+    
+    maybe.print.breakline(exists(prev));
+    
+    print('__label');
+    print(':');
+    print.breakline();
+    print('__body');
+    maybe.print.breakline(exists(next));
+};

package/packages/printer-fasm/printer/visitors/member-expression.js

@@ -0,0 +1,5 @@
+export const MemberExpression = (path, {print}) => {
+    print('__object');
+    print(' ');
+    print('__property');
+};

package/packages/printer-fasm/printer/visitors/sequence-expression.js

@@ -0,0 +1,17 @@
+import {types} from '@putout/babel';
+
+const {isMemberExpression} = types;
+
+export const SequenceExpression = (path, {traverse, maybe, write}) => {
+    const expressions = path.get('expressions');
+    const n = expressions.length - 1;
+    
+    for (const [i, expression] of expressions.entries()) {
+        traverse(expression);
+        
+        if (isMemberExpression(expression) || n > 1 && i < n)
+            write(',');
+        
+        maybe.write(i < n, ' ');
+    }
+};

package/packages/printer-fasm/printer/visitors/string-literal.js

@@ -0,0 +1,55 @@
+export const StringLiteral = (path, {write}, semantics) => {
+    const {value, raw = `'${value}'`} = path.node;
+    
+    if (path.parentPath.isJSXAttribute()) {
+        write(`"${value}"`);
+        return;
+    }
+    
+    const newValue = raw.slice(1, -1);
+    write.quote();
+    write(maybeEscape(newValue, semantics));
+    write.quote();
+};
+
+const maybeEscape = (value, {escapeDoubleQuote, escapeSingleQuote}) => {
+    const list = value.split('');
+    const slash = '\\';
+    
+    if (escapeSingleQuote)
+        return escape(list, {
+            slash,
+            quote: `'`,
+        });
+    
+    if (escapeDoubleQuote)
+        return escape(list, {
+            slash,
+            quote: `"`,
+        });
+    
+    return value;
+};
+
+const escape = (list, {slash, quote}) => {
+    const result = [];
+    
+    for (const [index, char] of list.entries()) {
+        const prev = list[index - 1];
+        const next = list[index + 1];
+        
+        if (char === slash && next === quote) {
+            result.push(quote);
+            continue;
+        }
+        
+        if (char === quote && prev !== slash) {
+            result.push(`${slash}${char}`);
+            continue;
+        }
+        
+        result.push(char);
+    }
+    
+    return result.join('');
+};

package/packages/printer-fasm/printer/visitors/tagged-template-expression.js

@@ -0,0 +1,4 @@
+export const TaggedTemplateExpression = (path, {write}) => {
+    const {value} = path.node.quasi.quasis[0];
+    write(value.cooked.trim());
+};

package/packages/printer-fasm/printer.js

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

package/packages/printer-wasm/printer/maybe-type-annotation.js

@@ -0,0 +1,15 @@
+export const maybeTypeAnnotation = (visit) => (path, printer, semantics) => {
+    visit(path, printer, semantics);
+    
+    maybePrintTypeAnnotation(path, printer);
+};
+
+export function maybePrintTypeAnnotation(path, printer) {
+    const {typeAnnotation} = path.node;
+    const {write, traverse} = printer;
+    
+    if (typeAnnotation) {
+        write.space();
+        traverse(path.get('typeAnnotation'));
+    }
+}

package/packages/printer-wasm/printer/params.js

@@ -0,0 +1,72 @@
+const parseParams = (path) => path.get('params');
+
+export const printParams = (path, printer, semantics, customization = {}) => {
+    const {extra, typeParameters} = path.node;
+    const {
+        print,
+        maybe,
+        traverse,
+    } = printer;
+    
+    const {
+        params = parseParams(path),
+        braceOpen = '(',
+        braceClose = ')',
+        printSpace = print.space,
+    } = customization;
+    
+    if (typeParameters)
+        traverse(path.get('typeParameters'));
+    
+    const n = params.length - 1;
+    
+    for (let i = 0; i <= n; i++) {
+        printBraceOpen(path, {
+            print,
+            braceOpen,
+        }, semantics);
+        
+        const isLast = i === n;
+        const current = params[i];
+        
+        print('$');
+        traverse(current);
+        
+        printBraceClose(path, {
+            print,
+            braceClose,
+        }, semantics);
+        
+        if (!isLast)
+            printSpace();
+    }
+    
+    maybe.print(extra?.trailingComma, ',');
+};
+
+function printBraceOpen(path, {print, braceOpen}, semantics) {
+    if (isOneArgArrow(path) && !semantics.roundBraces.arrow)
+        return;
+    
+    return print(braceOpen);
+}
+
+function printBraceClose(path, {print, braceClose}, semantics) {
+    if (isOneArgArrow(path) && !semantics.roundBraces.arrow)
+        return;
+    
+    print(braceClose);
+}
+
+function isOneArgArrow(path) {
+    if (path.type !== 'ArrowFunctionExpression')
+        return false;
+    
+    const {params} = path.node;
+    const [param] = params;
+    
+    if (params.length !== 1)
+        return false;
+    
+    return param.type === 'Identifier';
+}

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

@@ -0,0 +1,32 @@
+import {print as putoutPrint} from '@putout/printer';
+import {CallExpression} from './visitors/call-expression/call-expression.js';
+import {BlockStatement} from './visitors/block-statement.js';
+import {ExpressionStatement} from './visitors/expression-statement/expression-statement.js';
+import {ExportNamedDeclaration} from './visitors/export-named-declaration.js';
+import {FunctionDeclaration} from './visitors/function-declaration.js';
+import {Program} from './visitors/program.js';
+import {Identifier} from './visitors/identifier.js';
+import {ReturnStatement} from './visitors/return.js';
+import {IfStatement} from './visitors/if-statement.js';
+
+export const print = (ast) => {
+    return putoutPrint(ast, {
+        format: {
+            quote: '"',
+        },
+        semantics: {
+            comments: false,
+        },
+        visitors: {
+            ReturnStatement,
+            CallExpression,
+            BlockStatement,
+            IfStatement,
+            ExpressionStatement,
+            ExportNamedDeclaration,
+            FunctionDeclaration,
+            Program,
+            Identifier,
+        },
+    });
+};

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

@@ -0,0 +1,33 @@
+const isFirstStatement = (path) => path.node.body[0];
+const isFirstDirective = (path) => path.node.directives?.[0];
+
+export const BlockStatement = {
+    print(path, printer) {
+        const {
+            indent,
+            maybe,
+            write,
+            traverse,
+        } = printer;
+        
+        const body = path.get('body');
+        
+        if (path.parentPath.isBlockStatement())
+            indent();
+        
+        indent.inc();
+        
+        if (isFirstStatement(path) || isFirstDirective(path))
+            write.newline();
+        
+        for (const element of body) {
+            traverse(element);
+        }
+        
+        indent.dec();
+        maybe.indent(body.length);
+        
+        if (path.parentPath.isObjectMethod())
+            write(',');
+    },
+};

package/packages/printer-wasm/printer/visitors/call-expression/call-expression.js

@@ -0,0 +1,53 @@
+import {types} from '@putout/babel';
+import {isWasmType} from './is-wasm-type.js';
+
+const {isIdentifier} = types;
+const {isArray} = Array;
+
+const parseArgs = (path) => {
+    const argsPath = path.get('arguments');
+    
+    if (!isArray(argsPath))
+        return [];
+    
+    return argsPath;
+};
+
+export function CallExpression(path, {indent, print, maybe, traverse}) {
+    const args = parseArgs(path);
+    const n = args.length - 1;
+    const isParentCall = path.parentPath.isCallExpression();
+    const callee = path.get('callee');
+    
+    print('(');
+    
+    traverse(callee);
+    
+    maybe.print.space(args.length);
+    maybe.indent.inc(isParentCall);
+    
+    for (const [i, arg] of args.entries()) {
+        const isObject = arg.isObjectExpression();
+        
+        if (isParentCall && !isObject && n)
+            print.breakline();
+        
+        if (isIdentifier(arg) && !isWasmType(arg.node.name))
+            print('$');
+        
+        print(arg);
+        
+        if (isParentCall && n)
+            continue;
+        
+        if (i < n)
+            print(' ');
+    }
+    
+    if (isParentCall) {
+        indent.dec();
+        maybe.print.breakline(n);
+    }
+    
+    print(')');
+}

package/packages/printer-wasm/printer/visitors/call-expression/is-wasm-type.js

@@ -0,0 +1,6 @@
+const types = [
+    'i32',
+    'i64',
+];
+
+export const isWasmType = (name) => types.includes(name);

package/packages/printer-wasm/printer/visitors/export-named-declaration.js

@@ -0,0 +1,3 @@
+export const ExportNamedDeclaration = (path, {print}) => {
+    print('__declaration');
+};

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

@@ -0,0 +1,38 @@
+import {isNext, isPrev} from '@putout/printer/is';
+import {types} from 'putout';
+import {
+    isWastImport,
+    printWasmImport,
+} from './print-wasm-import.js';
+import {
+    isWastMemory,
+    printWasmMemory,
+} from './print-wasm-memory.js';
+
+const {isFunction} = types;
+
+export const ExpressionStatement = (path, printer) => {
+    const {print, maybe} = printer;
+    
+    const expression = path.get('expression');
+    
+    if (isWastImport(expression)) {
+        printWasmImport(expression, printer);
+        maybe.print.breakline(isNext(path));
+        
+        return;
+    }
+    
+    if (isWastMemory(expression)) {
+        printWasmMemory(expression, printer);
+        maybe.print.newline(isNext(path));
+        
+        return;
+    }
+    
+    const surrounded = isNext(path) || isFunction(path.parentPath.parentPath);
+    
+    maybe.indent(surrounded || isPrev(path));
+    print('__expression');
+    maybe.print.newline(surrounded);
+};

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

@@ -0,0 +1,81 @@
+import {types} from '@putout/babel';
+
+const {
+    isCallExpression,
+    isReturnStatement,
+} = types;
+
+export const isWastImport = (expression) => {
+    if (!isCallExpression(expression))
+        return;
+    
+    const {name} = expression.node.callee;
+    
+    return name === '__ishvara_wasm_import';
+};
+
+export function printWasmImport(path, printer) {
+    const {print, maybe} = printer;
+    
+    const [first, second, func] = path.get('arguments');
+    
+    print('(import ');
+    
+    print(first);
+    print(' ');
+    print(second);
+    print(' ');
+    print('(func ');
+    
+    const {name: funcName} = func.node.id;
+    const funcArgs = func.get('params');
+    const returnType = getReturnType(func);
+    
+    print(`$${funcName} `);
+    
+    const n = funcArgs.length - 1;
+    
+    for (const [i, funcArg] of funcArgs.entries()) {
+        printParam(funcArg, printer);
+        maybe.print.space(i < n);
+    }
+    
+    if (returnType) {
+        maybe.print.space(funcArgs.length);
+        print('(result ');
+        print(returnType);
+        print(')');
+    }
+    
+    print(')');
+    print(')');
+}
+
+function getReturnType(func) {
+    const [first] = func.get('body.body');
+    
+    if (!first)
+        return null;
+    
+    if (isReturnStatement(first))
+        return first.get('argument');
+    
+    return first.get('expression');
+}
+
+function printParam(funcArg, {print}) {
+    const {name, typeAnnotation} = funcArg.node;
+    
+    if (!typeAnnotation) {
+        print(`(param `);
+        print(name);
+        print(`)`);
+        
+        return;
+    }
+    
+    print(`(param `);
+    print(`$${name} `);
+    print(funcArg.get('typeAnnotation.typeAnnotation'));
+    print(`)`);
+}