mutation.js

const fs = require("fs");
const path = require("path");
const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const generator = require("@babel/generator").default;

const JSON_DIR = "./json_corpus";

const EXPRESSION_TYPES = new Set([
    "AssignmentExpression", "BinaryExpression", "LogicalExpression",
    "UnaryExpression", "CallExpression", "MemberExpression",
    "ConditionalExpression", "NewExpression", "ArrayExpression",
    "ObjectExpression", "SequenceExpression", "UpdateExpression",
    "ThisExpression", "SuperExpression", "TaggedTemplateExpression",
    "TemplateLiteral", "AwaitExpression", "YieldExpression",
    "ArrowFunctionExpression", "FunctionExpression", "ClassExpression",
    "ParenthesizedExpression", "ExpressionStatement",
]);

const FILE_PATH = process.argv[2];
if (!FILE_PATH) {
    console.error("Usage: node mutation.js <path>");
    process.exit(1);
}

function loadRandomJson(directory) {
    const files = fs.readdirSync(directory).filter(f => f.endsWith(".json"));
    if (files.length === 0) {
        console.error(`No JSON files in: ${directory}`);
        process.exit(1);
    }
    const selected = files[Math.floor(Math.random() * files.length)];
    return JSON.parse(fs.readFileSync(path.join(directory, selected), "utf-8"));
}

const code = fs.readFileSync(FILE_PATH, "utf-8");

const ast = parser.parse(code, {
    sourceType: "module",
    errorRecovery: true,
    plugins: [
        "jsx", "typescript", "classProperties",
        "optionalChaining", "nullishCoalescingOperator", "dynamicImport",
    ],
});

const blockStatements = [];
const expressions = [];

traverse(ast, {
    enter(path) {
        if (path.node.type === "BlockStatement") {
            blockStatements.push(path);
        }
        if (EXPRESSION_TYPES.has(path.node.type)) {
            expressions.push(path);
        }
    },
});

const operations = [];
if (blockStatements.length > 0) operations.push("insertExpressionStatement");
if (expressions.length > 0)     operations.push("subtreeChange");

if (operations.length === 0) {
    process.exit(0);
}

const selectedOp = operations[Math.floor(Math.random() * operations.length)];

switch (selectedOp) {
    case "insertExpressionStatement": {
        const block = blockStatements[Math.floor(Math.random() * blockStatements.length)];
        const insertIndex = Math.floor(Math.random() * (block.node.body.length + 1));
        const newStatement = loadRandomJson(`${JSON_DIR}/ExpressionStatement`);
        block.node.body.splice(insertIndex, 0, newStatement);
        break;
    }
    case "subtreeChange": {
        const target = expressions[Math.floor(Math.random() * expressions.length)];
        const typeDir = path.join(JSON_DIR, target.node.type);
        const replacement = loadRandomJson(typeDir);
        target.replaceWith(replacement);
        break;
    }
}

console.log(generator(ast, { compact: false }).code);