feature: @putout/operate: addParens, removeParens: add

Author: coderaiser

packages/operate/README.md

@@ -254,6 +254,28 @@ const object = template.ast('x({"a": "b"})');
 const [propertyPath] = traverseProperties(object, 'a');
 ```
 
+### `addParens(path: Path)`
+
+Add parens around expression depending on used `printer`:
+
+- ✅ set `node.extra.parenthesized: true` when `@putout/printer` used;
+- ✅ set add `ParenthesizedExpression` or `TSParenthesizedType` when `babel` used;
+
+```js
+addParens(path);
+```
+
+### `removeParens(path: Path)`
+
+Remove parens around expression depending on used `printer`:
+
+- ✅ set `node.extra.parenthesized: false` when `@putout/printer` used;
+- ✅ remove `ParenthesizedExpression` or `TSParenthesizedType` when `babel` used;
+
+```js
+removeParens(path);
+```
+
 ## License
 
 MIT

packages/operate/lib/operate.js

@@ -12,6 +12,7 @@ const {rename} = require('./rename');
 const {renameProperty} = require('./rename-property');
 const {setLiteralValue} = require('./set-literal-value');
 const {getPathAfterRequires} = require('./get-path-after-requires');
+const {addParens, removeParens} = require('./parens');
 
 const {
     getProperty,
@@ -48,6 +49,9 @@ module.exports.rename = rename;
 module.exports.renameProperty = renameProperty;
 module.exports.setLiteralValue = setLiteralValue;
 
+module.exports.addParens = addParens;
+module.exports.removeParens = removeParens;
+
 module.exports.getProperty = getProperty;
 module.exports.getProperties = getProperties;
 module.exports.traverseProperties = traverseProperties;

packages/operate/lib/parens.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {types} = require('@putout/babel');
+const {
+    ParenthesizedExpression,
+    TSParenthesizedType,
+} = types;
+
+module.exports.addParens = (path) => {
+    const printer = getPrinter(path);
+    
+    if (printer !== 'babel') {
+        const {extra = {}} = path.node;
+        
+        extra.parenthesized = true;
+        path.node.extra = extra;
+        
+        return;
+    }
+    
+    const {node} = path;
+    
+    if (path.type.startsWith('TS'))
+        return path.replaceWith(TSParenthesizedType(node));
+    
+    path.replaceWith(ParenthesizedExpression(node));
+};
+
+module.exports.removeParens = (path) => {
+    const printer = getPrinter(path);
+    
+    if (printer !== 'babel')
+        return path.node.extra.parenthesized = false;
+    
+    const {node} = path;
+    path.parentPath.replaceWith(node);
+};
+
+function getPrinter(path) {
+    const scope = path.scope.getProgramParent();
+    const programPath = scope.path;
+    
+    return programPath.node.extra.__putout_printer;
+}

packages/operate/lib/parens.spec.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const test = require('supertape');
+
+const {
+    parse,
+    print,
+    traverse,
+} = require('putout');
+
+const {addParens, removeParens} = require('./parens');
+
+test('putout: operate: parens: removeParens: putout', (t) => {
+    const source = '(b = 3)';
+    const ast = parse(source);
+    
+    traverse(ast, {
+        AssignmentExpression: removeParens,
+    });
+    
+    const result = print(ast);
+    const expected = 'b = 3;\n';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('putout: operate: parens: removeParens: babel', (t) => {
+    const source = '(b = 3)';
+    const ast = parse(source, {
+        printer: 'babel',
+    });
+    
+    traverse(ast, {
+        AssignmentExpression(path) {
+            removeParens(path);
+            path.stop();
+        },
+    });
+    
+    const result = print(ast, {
+        printer: 'babel',
+    });
+    
+    const expected = 'b = 3;\n';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('putout: operate: parens: addParens', (t) => {
+    const source = 'const b = a';
+    const ast = parse(source);
+    
+    traverse(ast, {
+        VariableDeclarator(path) {
+            addParens(path.get('init'));
+            path.stop();
+        },
+    });
+    
+    const result = print(ast);
+    const expected = 'const b = (a);\n';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('putout: operate: parens: addParens: babel', (t) => {
+    const source = 'b = 3';
+    const ast = parse(source, {
+        printer: 'babel',
+    });
+    
+    traverse(ast, {
+        AssignmentExpression(path) {
+            addParens(path);
+            path.stop();
+        },
+    });
+    
+    const result = print(ast, {
+        printer: 'babel',
+    });
+    
+    const expected = '(b = 3);\n';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('putout: operate: parens: addParens: babel: ts', (t) => {
+    const source = 'const a: boolean = true;';
+    const ast = parse(source, {
+        printer: 'babel',
+        isTS: true,
+    });
+    
+    traverse(ast, {
+        TSBooleanKeyword(path) {
+            addParens(path);
+            path.stop();
+        },
+    });
+    
+    const result = print(ast, {
+        printer: 'babel',
+    });
+    
+    const expected = 'const a: (boolean) = true;\n';
+    
+    t.equal(result, expected);
+    t.end();
+});

packages/operate/lib/properties/traverse-properties.js

@@ -3,20 +3,14 @@
 const {traverse, types} = require('@putout/babel');
 const {extract} = require('../extract');
 
-const {
-    isObjectExpression,
-    isCallExpression,
-} = types;
+const {isObjectExpression} = types;
 
 const nodeOrPath = (path) => path.node || path;
 
 function getNode(path) {
     if (!isObjectExpression(path))
         return nodeOrPath(path);
 
-    if (isCallExpression(path.parentPath))
-        return path.parentPath.node;
-    
     return {
         type: 'ExpressionStatement',
         expression: nodeOrPath(path),

packages/operate/lib/replace-with/replace-with.js

@@ -3,17 +3,8 @@
 const {maybeBody} = require('./maybe-body');
 const {assign} = Object;
 
-const parseNode = (a) => {
-    a = extractMark(a);
-    
-    if (a.node)
-        return a.node;
-    
-    return a;
-};
-
 module.exports.replaceWith = (path, node) => {
-    node = parseNode(node);
+    node = extractMark(node);
 
     if (path?.parentPath?.isExpressionStatement() && !path.parentPath.isProgram()) {
         addMark(path, node);

packages/operate/test/operate.js

@@ -1053,3 +1053,42 @@ test('putout: operate: getLiteralRaw', (t) => {
     t.equal(result, raw);
     t.end();
 });
+
+test('putout: operate: addParens', (t) => {
+    const source = 'const a: boolean = true;';
+    const ast = parse(source, {
+        printer: 'babel',
+        isTS: true,
+    });
+    
+    traverse(ast, {
+        TSBooleanKeyword(path) {
+            operate.addParens(path);
+            path.stop();
+        },
+    });
+    
+    const result = print(ast, {
+        printer: 'babel',
+    });
+    
+    const expected = 'const a: (boolean) = true;\n';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('putout: operate: removeParens', (t) => {
+    const source = '(b = 3)';
+    const ast = parse(source);
+    
+    traverse(ast, {
+        AssignmentExpression: operate.removeParens,
+    });
+    
+    const result = print(ast);
+    const expected = 'b = 3;\n';
+    
+    t.equal(result, expected);
+    t.end();
+});