nalloc 0.2.2 → 0.5.0

package/build/codemod.cjs

@@ -0,0 +1,652 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get migrateSource () {
+        return migrateSource;
+    },
+    get renderReport () {
+        return renderReport;
+    }
+});
+const _oxcparser = require("oxc-parser");
+const INSTANCE_METHODS = new Map([
+    [
+        'map',
+        {
+            fn: 'map',
+            ambiguous: true
+        }
+    ],
+    [
+        'mapErr',
+        {
+            fn: 'mapErr'
+        }
+    ],
+    [
+        'andThen',
+        {
+            fn: 'flatMap'
+        }
+    ],
+    [
+        'orElse',
+        {
+            fn: 'orElse'
+        }
+    ],
+    [
+        'match',
+        {
+            fn: 'match'
+        }
+    ],
+    [
+        'unwrapOr',
+        {
+            fn: 'unwrapOr'
+        }
+    ],
+    [
+        'isOk',
+        {
+            fn: 'isOk'
+        }
+    ],
+    [
+        'isErr',
+        {
+            fn: 'isErr'
+        }
+    ],
+    [
+        'andTee',
+        {
+            fn: 'tap'
+        }
+    ],
+    [
+        'orTee',
+        {
+            fn: 'tapErr'
+        }
+    ],
+    [
+        '_unsafeUnwrap',
+        {
+            fn: 'unwrap'
+        }
+    ],
+    [
+        '_unsafeUnwrapErr',
+        {
+            fn: 'unwrapErr'
+        }
+    ]
+]);
+const ASYNC_INSTANCE_METHODS = new Set([
+    'asyncMap',
+    'asyncAndThen',
+    'asyncAndThrough'
+]);
+const UNSUPPORTED_INSTANCE_METHODS = new Set([
+    'andThrough',
+    'safeUnwrap'
+]);
+const ASYNC_IMPORTS = new Set([
+    'ResultAsync',
+    'okAsync',
+    'errAsync',
+    'fromSafePromise',
+    'fromAsyncThrowable'
+]);
+const STATIC_METHODS = new Map([
+    [
+        'fromThrowable',
+        'wrap'
+    ],
+    [
+        'combine',
+        'all'
+    ],
+    [
+        'combineWithAllErrors',
+        'collectAll'
+    ]
+]);
+function isNode(value) {
+    return typeof value === 'object' && value !== null && typeof value.type === 'string';
+}
+function eachChild(node, visit) {
+    for (const key of Object.keys(node)){
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const item of value){
+                if (isNode(item)) visit(item);
+            }
+        } else if (isNode(value)) {
+            visit(value);
+        }
+    }
+}
+function annotationTypeName(id) {
+    const annotation = id.typeAnnotation;
+    const ref = annotation?.typeAnnotation;
+    if (ref?.type !== 'TSTypeReference') return undefined;
+    const typeName = ref.typeName;
+    return typeName.type === 'Identifier' ? typeName.name : undefined;
+}
+function collectImports(program) {
+    const locals = new Map();
+    const declarations = [];
+    let hasNamespace = false;
+    for (const stmt of program.body){
+        if (stmt.type !== 'ImportDeclaration' || stmt.source.value !== 'neverthrow') continue;
+        declarations.push(stmt);
+        for (const spec of stmt.specifiers){
+            if (spec.type === 'ImportNamespaceSpecifier') {
+                hasNamespace = true;
+            } else if (spec.type === 'ImportSpecifier') {
+                const imported = spec.imported;
+                if (imported.type === 'Identifier') {
+                    locals.set(spec.local.name, imported.name);
+                }
+            }
+        }
+    }
+    return {
+        locals,
+        declarations,
+        hasNamespace
+    };
+}
+class FileMigration {
+    file;
+    source;
+    imports;
+    edits = [];
+    skipped = [];
+    resultIds = new Set();
+    asyncIds = new Set();
+    wrappedFns = new Set();
+    resultFns = new Set();
+    conflicted = new Set();
+    residualNames = new Set();
+    converted = 0;
+    needsNamespace = false;
+    needsPipe = false;
+    needsResultType = false;
+    usedTypeNames = new Set();
+    constructor(file, source, imports){
+        this.file = file;
+        this.source = source;
+        this.imports = imports;
+    }
+    importedAs(local) {
+        return this.imports.locals.get(local);
+    }
+    isFromPromiseCall(node) {
+        return node.type === 'CallExpression' && node.callee.type === 'Identifier' && this.importedAs(node.callee.name) === 'fromPromise';
+    }
+    lineOf(offset) {
+        let line = 1;
+        for(let i = 0; i < offset; i++){
+            if (this.source.charCodeAt(i) === 10) line++;
+        }
+        return line;
+    }
+    report(reason, node) {
+        this.skipped.push({
+            file: this.file,
+            line: this.lineOf(node.start),
+            reason,
+            text: this.source.slice(node.start, Math.min(node.end, node.start + 120))
+        });
+    }
+    classify(node) {
+        if (node.type === 'Identifier') {
+            const name = node.name;
+            if (this.conflicted.has(name)) return undefined;
+            if (this.asyncIds.has(name)) return 'async';
+            if (this.resultIds.has(name)) return 'result';
+            return undefined;
+        }
+        if (node.type === 'AwaitExpression') {
+            if (this.isFromPromiseCall(node.argument)) return 'result';
+            return this.classify(node.argument) === 'async' ? 'async' : undefined;
+        }
+        if (node.type === 'CallExpression') {
+            const callee = node.callee;
+            if (callee.type === 'Identifier') {
+                const name = callee.name;
+                const imported = this.importedAs(name);
+                if (imported === 'ok' || imported === 'err' || imported === 'combine' || imported === 'combineWithAllErrors') return 'result';
+                if (imported !== undefined && (ASYNC_IMPORTS.has(imported) || imported === 'fromPromise')) return 'async';
+                if (this.wrappedFns.has(name) || this.resultFns.has(name)) return 'result';
+                return undefined;
+            }
+            if (callee.type === 'MemberExpression' && !callee.computed) {
+                const property = callee.property;
+                const object = callee.object;
+                if (property.type !== 'Identifier') return undefined;
+                const method = property.name;
+                if (object.type === 'Identifier') {
+                    const objImported = this.importedAs(object.name);
+                    if (objImported === 'Result' && STATIC_METHODS.has(method)) {
+                        return method === 'fromThrowable' ? undefined : 'result';
+                    }
+                    if (objImported === 'ResultAsync') return 'async';
+                }
+                const receiver = this.classify(object);
+                if (receiver === 'async') return 'async';
+                if (receiver === 'result') {
+                    if (ASYNC_INSTANCE_METHODS.has(method)) return 'async';
+                    if (INSTANCE_METHODS.has(method)) return 'result';
+                }
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    classifyBinding(id, init) {
+        if (id.type !== 'Identifier') return;
+        const name = id.name;
+        const typeName = annotationTypeName(id);
+        const annotated = typeName !== undefined ? this.importedAs(typeName) : undefined;
+        const fromInit = (()=>{
+            if (init === null) return undefined;
+            if (init.type === 'CallExpression') {
+                const callee = init.callee;
+                const calleeImported = callee.type === 'Identifier' ? this.importedAs(callee.name) : undefined;
+                if (calleeImported === 'fromThrowable') return 'wrapped';
+                if (callee.type === 'MemberExpression') {
+                    const object = callee.object;
+                    const property = callee.property;
+                    if (object.type === 'Identifier' && property.type === 'Identifier' && this.importedAs(object.name) === 'Result' && property.name === 'fromThrowable') {
+                        return 'wrapped';
+                    }
+                }
+            }
+            return this.classify(init);
+        })();
+        const kind = annotated === 'Result' || annotated === 'Ok' || annotated === 'Err' ? 'result' : annotated === 'ResultAsync' ? 'async' : fromInit;
+        if (kind === 'result') {
+            this.addClassified(name, this.resultIds);
+        } else if (kind === 'async') {
+            this.addClassified(name, this.asyncIds);
+        } else if (kind === 'wrapped') {
+            this.addClassified(name, this.wrappedFns);
+        } else {
+            if (this.resultIds.has(name) || this.asyncIds.has(name) || this.wrappedFns.has(name)) {
+                this.conflicted.add(name);
+            }
+        }
+    }
+    addClassified(name, target) {
+        if ((this.resultIds.has(name) || this.asyncIds.has(name) || this.wrappedFns.has(name)) && !target.has(name)) {
+            this.conflicted.add(name);
+            return;
+        }
+        target.add(name);
+    }
+    collectProvenance(node) {
+        if (node.type === 'VariableDeclarator') {
+            this.classifyBinding(node.id, node.init);
+        } else if (node.type === 'AssignmentExpression' && node.operator === '=') {
+            this.classifyBinding(node.left, node.right);
+        } else if (node.type === 'FunctionDeclaration' || node.type === 'TSDeclareFunction') {
+            const id = node.id;
+            const returnType = node.returnType;
+            if (id?.type === 'Identifier' && returnType !== null) {
+                const ref = returnType.typeAnnotation;
+                if (ref.type === 'TSTypeReference' && ref.typeName.type === 'Identifier') {
+                    const imported = this.importedAs(ref.typeName.name);
+                    if (imported === 'Result') this.resultFns.add(id.name);
+                }
+            }
+            for (const param of node.params){
+                this.classifyBinding(param, null);
+            }
+        } else if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
+            for (const param of node.params){
+                this.classifyBinding(param, null);
+            }
+        }
+        eachChild(node, (child)=>this.collectProvenance(child));
+    }
+    takeEditsWithin(start, end) {
+        const inside = [];
+        for(let i = this.edits.length - 1; i >= 0; i--){
+            const edit = this.edits[i];
+            if (edit.start >= start && edit.end <= end) {
+                inside.push(edit);
+                this.edits.splice(i, 1);
+            }
+        }
+        return inside;
+    }
+    render(start, end) {
+        const inside = this.takeEditsWithin(start, end).sort((a, b)=>b.start - a.start);
+        let text = this.source.slice(start, end);
+        for (const edit of inside){
+            text = text.slice(0, edit.start - start) + edit.text + text.slice(edit.end - start);
+        }
+        return text;
+    }
+    renderArgs(args) {
+        if (args.length === 0) return '';
+        return this.render(args[0].start, args[args.length - 1].end);
+    }
+    convert(node, parent, grandparent) {
+        if (node.type === 'TSTypeReference') {
+            const typeName = node.typeName;
+            if (typeName.type === 'Identifier') {
+                const imported = this.importedAs(typeName.name);
+                if (imported === 'Result') {
+                    this.edits.push({
+                        start: typeName.start,
+                        end: typeName.end,
+                        text: 'ResultType'
+                    });
+                    this.needsResultType = true;
+                } else if (imported === 'Ok' || imported === 'Err') {
+                    this.usedTypeNames.add(imported);
+                }
+            }
+        }
+        if (node.type === 'CallExpression') {
+            const consumedByOuterChain = parent?.type === 'MemberExpression' && parent.object === node && !parent.computed && parent.property.type === 'Identifier' && grandparent?.type === 'CallExpression' && grandparent.callee === parent && (INSTANCE_METHODS.has(parent.property.name) || ASYNC_INSTANCE_METHODS.has(parent.property.name) || UNSUPPORTED_INSTANCE_METHODS.has(parent.property.name));
+            if (!consumedByOuterChain && this.convertCall(node)) return;
+        }
+        eachChild(node, (child)=>this.convert(child, node, parent));
+    }
+    convertCall(node) {
+        const callee = node.callee;
+        if (callee.type === 'Identifier') {
+            const imported = this.importedAs(callee.name);
+            if (imported === undefined) return false;
+            if (imported === 'fromThrowable' || imported === 'combine' || imported === 'combineWithAllErrors') {
+                this.edits.push({
+                    start: callee.start,
+                    end: callee.end,
+                    text: `Result.${STATIC_METHODS.get(imported)}`
+                });
+                this.needsNamespace = true;
+                this.converted++;
+                return false;
+            }
+            if (imported === 'safeTry') {
+                this.report('safe-try', node);
+                this.residualNames.add(callee.name);
+                return false;
+            }
+            if (ASYNC_IMPORTS.has(imported)) {
+                this.report('result-async', node);
+                this.residualNames.add(callee.name);
+                return false;
+            }
+            return false;
+        }
+        if (callee.type !== 'MemberExpression' || callee.computed || callee.property.type !== 'Identifier') {
+            return false;
+        }
+        const object = callee.object;
+        const method = callee.property.name;
+        if (object.type === 'Identifier') {
+            const objImported = this.importedAs(object.name);
+            if (objImported === 'Result' && STATIC_METHODS.has(method)) {
+                this.edits.push({
+                    start: callee.start,
+                    end: callee.end,
+                    text: `Result.${STATIC_METHODS.get(method)}`
+                });
+                this.needsNamespace = true;
+                this.converted++;
+                return false;
+            }
+            if (objImported === 'ResultAsync') {
+                this.report('result-async', node);
+                this.residualNames.add(object.name);
+                return false;
+            }
+        }
+        if (!INSTANCE_METHODS.has(method) && !ASYNC_INSTANCE_METHODS.has(method) && !UNSUPPORTED_INSTANCE_METHODS.has(method)) {
+            return false;
+        }
+        const links = [];
+        let current = node;
+        let blocked;
+        while(true){
+            const currentCallee = current.callee;
+            const currentMethod = currentCallee.property.name;
+            if (ASYNC_INSTANCE_METHODS.has(currentMethod)) {
+                blocked = 'result-async';
+                break;
+            }
+            if (UNSUPPORTED_INSTANCE_METHODS.has(currentMethod)) {
+                blocked = 'unsupported';
+                break;
+            }
+            links.unshift({
+                call: current,
+                method: currentMethod
+            });
+            const receiver = currentCallee.object;
+            if (receiver.type === 'CallExpression' && receiver.callee.type === 'MemberExpression' && !receiver.callee.computed && receiver.callee.property.type === 'Identifier' && (INSTANCE_METHODS.has(receiver.callee.property.name) || ASYNC_INSTANCE_METHODS.has(receiver.callee.property.name) || UNSUPPORTED_INSTANCE_METHODS.has(receiver.callee.property.name))) {
+                current = receiver;
+                continue;
+            }
+            break;
+        }
+        if (blocked !== undefined) {
+            this.report(blocked, node);
+            const blockedCall = current;
+            eachChild(node, (child)=>{
+                if (child !== blockedCall) this.convert(child, node, undefined);
+            });
+            return true;
+        }
+        const base = links[0].call.callee.object;
+        const baseKind = this.classify(base);
+        if (baseKind === 'async') {
+            this.report('result-async', node);
+            return true;
+        }
+        const hasExclusive = links.some((link)=>!INSTANCE_METHODS.get(link.method).ambiguous);
+        if (baseKind !== 'result' && !hasExclusive) {
+            return false;
+        }
+        this.convert(base, undefined, undefined);
+        for (const link of links){
+            for (const arg of link.call.arguments){
+                this.convert(arg, link.call, undefined);
+            }
+        }
+        const baseText = this.render(base.start, base.end);
+        this.needsNamespace = true;
+        this.converted += links.length;
+        const replacement = (()=>{
+            if (links.length === 1) {
+                const { fn } = INSTANCE_METHODS.get(links[0].method);
+                const args = this.renderArgs(links[0].call.arguments);
+                return `Result.${fn}(${baseText}${args.length > 0 ? `, ${args}` : ''})`;
+            }
+            this.needsPipe = true;
+            const steps = links.map((link)=>{
+                const { fn } = INSTANCE_METHODS.get(link.method);
+                const args = this.renderArgs(link.call.arguments);
+                return `($r) => Result.${fn}($r${args.length > 0 ? `, ${args}` : ''})`;
+            });
+            return `pipe(${baseText}, ${steps.join(', ')})`;
+        })();
+        this.edits.push({
+            start: node.start,
+            end: node.end,
+            text: replacement
+        });
+        return true;
+    }
+    awaitedFromPromise = new Set();
+    convertAwaitedFromPromise(node) {
+        if (node.type === 'AwaitExpression' && this.isFromPromiseCall(node.argument)) {
+            const call = node.argument;
+            this.edits.push({
+                start: call.callee.start,
+                end: call.callee.end,
+                text: 'Result.fromPromise'
+            });
+            this.awaitedFromPromise.add(call);
+            this.needsNamespace = true;
+            this.converted++;
+        }
+        eachChild(node, (child)=>this.convertAwaitedFromPromise(child));
+    }
+    reportUnconvertedFromPromise(node) {
+        if (this.isFromPromiseCall(node) && !this.awaitedFromPromise.has(node)) {
+            this.report('result-async', node);
+            this.residualNames.add(node.callee.name);
+        }
+        eachChild(node, (child)=>this.reportUnconvertedFromPromise(child));
+    }
+    rewriteImports() {
+        const valueNames = [];
+        const typeNames = [];
+        for (const [local, imported] of this.imports.locals){
+            if (imported === 'ok' || imported === 'err') {
+                valueNames.push(imported === local ? imported : `${imported} as ${local}`);
+            }
+        }
+        if (this.needsNamespace) valueNames.push('Result');
+        if (this.needsPipe) valueNames.push('pipe');
+        if (this.needsResultType) typeNames.push('type ResultType');
+        for (const name of this.usedTypeNames)typeNames.push(`type ${name}`);
+        const statements = [];
+        const names = [
+            ...valueNames,
+            ...typeNames
+        ];
+        if (names.length > 0) {
+            statements.push(`import { ${names.join(', ')} } from 'nalloc';`);
+        }
+        const residual = [
+            ...this.residualNames
+        ].map((local)=>{
+            const imported = this.importedAs(local);
+            return imported === local ? imported : `${imported} as ${local}`;
+        });
+        if (residual.length > 0) {
+            statements.push(`import { ${residual.join(', ')} } from 'neverthrow';`);
+        }
+        const [first, ...rest] = this.imports.declarations;
+        this.edits.push({
+            start: first.start,
+            end: first.end,
+            text: statements.join('\n')
+        });
+        for (const decl of rest){
+            const end = this.source.charCodeAt(decl.end) === 10 ? decl.end + 1 : decl.end;
+            this.edits.push({
+                start: decl.start,
+                end,
+                text: ''
+            });
+        }
+    }
+    apply() {
+        const sorted = [
+            ...this.edits
+        ].sort((a, b)=>b.start - a.start);
+        let output = this.source;
+        for (const edit of sorted){
+            output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+        }
+        return output;
+    }
+}
+function migrateSource(source, file) {
+    const parsed = (0, _oxcparser.parseSync)(file, source);
+    if (parsed.errors.some((e)=>e.severity === 'Error')) {
+        return {
+            output: source,
+            changed: false,
+            converted: 0,
+            skipped: [
+                {
+                    file,
+                    line: 1,
+                    reason: 'unsupported',
+                    text: 'file has parse errors'
+                }
+            ]
+        };
+    }
+    const program = parsed.program;
+    const imports = collectImports(program);
+    if (imports.declarations.length === 0) {
+        return {
+            output: source,
+            changed: false,
+            converted: 0,
+            skipped: []
+        };
+    }
+    const migration = new FileMigration(file, source, imports);
+    if (imports.hasNamespace) {
+        migration.report('namespace-import', imports.declarations[0]);
+        return {
+            output: source,
+            changed: false,
+            converted: 0,
+            skipped: migration.skipped
+        };
+    }
+    migration.collectProvenance(program);
+    migration.convertAwaitedFromPromise(program);
+    migration.convert(program, undefined, undefined);
+    migration.reportUnconvertedFromPromise(program);
+    migration.rewriteImports();
+    const output = migration.apply();
+    return {
+        output,
+        changed: output !== source,
+        converted: migration.converted,
+        skipped: migration.skipped
+    };
+}
+function renderReport(report) {
+    const lines = [
+        '# nalloc migration report',
+        '',
+        `Files changed: ${report.filesChanged}. Sites converted: ${report.converted}. Sites needing manual review: ${report.skipped.length}.`,
+        ''
+    ];
+    const byFile = new Map();
+    for (const site of report.skipped){
+        const sites = byFile.get(site.file);
+        if (sites === undefined) {
+            byFile.set(site.file, [
+                site
+            ]);
+        } else {
+            sites.push(site);
+        }
+    }
+    for (const [file, sites] of byFile){
+        lines.push(`## ${file}`, '');
+        for (const site of sites){
+            lines.push(`- line ${site.line} [${site.reason}]: \`${site.text}\``);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+
+//# sourceMappingURL=codemod.cjs.map