@putout/printer 3.3.0 → 3.5.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.08.10, v3.5.0
+
+feature:
+- ae4808e maybeParens
+
+2023.08.10, v3.4.0
+
+feature:
+- d29fdfd (Arrow)FunctionExpression: parens
+
 2023.08.10, v3.3.0
 
 feature:

package/lib/tokenize/expressions/call-expression.js

@@ -7,16 +7,12 @@ function CallExpression(path, {indent, print, maybe, traverse}) {
     
     const callee = path.get('callee');
     const typeParameters = path.get('typeParameters');
-    const isFn = callee.isFunction();
     
-    maybe.write(isFn, '(');
     traverse(callee);
     
     if (exists(typeParameters))
         traverse(typeParameters);
     
-    maybe.write(isFn, ')');
-    
     if (path.node.optional)
         print('?.');
     

package/lib/tokenize/expressions/function/arrow-function-expression.js

@@ -2,51 +2,40 @@
 
 const {exists} = require('../../is');
 const {printParams} = require('./params');
+const {maybeParens} = require('./parens');
 
-module.exports.ArrowFunctionExpression = {
-    condition({parentPath}) {
-        return parentPath.isLogicalExpression();
-    },
-    before(path, {write}) {
-        write('(');
-    },
-    print(path, printer, semantics) {
-        const {
-            print,
-            maybe,
-            write,
-            traverse,
-        } = printer;
-        
-        const {async} = path.node;
-        
-        print('__typeParameters');
-        
-        maybe.print(async, 'async ');
-        
-        printParams(path, printer, semantics);
-        
-        const returnType = path.get('returnType');
-        
-        if (exists(returnType)) {
-            write(':');
-            write.space();
-            traverse(returnType);
-        }
-        
-        print.space();
-        print('=>');
-        
-        const body = path.get('body');
-        
-        const insideCall = path.parentPath.isCallExpression();
-        const isJSX = body.isJSXElement();
-        
-        maybe.print.space(!insideCall && isJSX);
-        maybe.print.space(!isJSX);
-        print('__body');
-    },
-    after(path, {write}) {
-        write(')');
-    },
-};
+module.exports.ArrowFunctionExpression = maybeParens((path, printer, semantics) => {
+    const {
+        print,
+        maybe,
+        write,
+        traverse,
+    } = printer;
+    
+    const {async} = path.node;
+    
+    print('__typeParameters');
+    maybe.print(async, 'async ');
+    
+    printParams(path, printer, semantics);
+    
+    const returnType = path.get('returnType');
+    
+    if (exists(returnType)) {
+        write(':');
+        write.space();
+        traverse(returnType);
+    }
+    
+    print.space();
+    print('=>');
+    
+    const body = path.get('body');
+    
+    const insideCall = path.parentPath.isCallExpression();
+    const isJSX = body.isJSXElement();
+    
+    maybe.print.space(!insideCall && isJSX);
+    maybe.print.space(!isJSX);
+    print('__body');
+});

package/lib/tokenize/expressions/function/function-expression.js

@@ -2,8 +2,9 @@
 
 const {exists} = require('../../is');
 const {printParams} = require('./params');
+const {maybeParens} = require('./parens');
 
-module.exports.FunctionExpression = (path, printer, semantics) => {
+module.exports.FunctionExpression = maybeParens((path, printer, semantics) => {
     const {
         print,
         maybe,
@@ -29,4 +30,4 @@ module.exports.FunctionExpression = (path, printer, semantics) => {
     
     print.space();
     print('__body');
-};
+});

package/lib/tokenize/expressions/function/parens.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports.maybeParens = (print) => ({
+    condition(path) {
+        return path.node.extra?.parenthesized;
+    },
+    before(path, {write}) {
+        write('(');
+    },
+    print,
+    after(path, {write}) {
+        write(')');
+    },
+});

package/lib/tokenize/expressions/unary-expression/unary-expressions.js

@@ -1,10 +1,21 @@
 'use strict';
 
 const {isLast, isNext} = require('../../is');
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = require('./parens');
+
+const {maybeParens} = require('../function/parens');
+
+const isWord = (a) => /^(delete|typeof|void|throw)$/.test(a);
+
+const unaryExpression = maybeParens((path, printer) => {
+    const {maybe, traverse} = printer;
+    const {prefix, operator} = path.node;
+    const argPath = path.get('argument');
+    
+    maybe.print(prefix, operator);
+    maybe.print(isWord(operator), ' ');
+    traverse(argPath);
+    maybe.print(!prefix, operator);
+});
 
 module.exports.UnaryExpression = unaryExpression;
 module.exports.UpdateExpression = unaryExpression;
@@ -40,20 +51,3 @@ function printUnary(path, name, {print}) {
     print(`${name} `);
     print('__argument');
 }
-
-const isWord = (a) => /^(delete|typeof|void|throw)$/.test(a);
-
-function unaryExpression(path, printer) {
-    const {maybe, traverse} = printer;
-    const {prefix, operator} = path.node;
-    const argPath = path.get('argument');
-    
-    maybeParenOpen(path, printer);
-    
-    maybe.print(prefix, operator);
-    maybe.print(isWord(operator), ' ');
-    traverse(argPath);
-    maybe.print(!prefix, operator);
-    
-    maybeParenClose(path, printer);
-}

package/lib/tokenize/literals/identifier.js

@@ -1,13 +1,9 @@
 'use strict';
 
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = require('../expressions/unary-expression/parens');
-
 const {maybeDecorators} = require('../maybe-get');
+const {maybeParens} = require('../expressions/function/parens');
 
-module.exports.Identifier = (path, printer) => {
+module.exports.Identifier = maybeParens((path, printer) => {
     const {
         write,
         maybe,
@@ -20,8 +16,6 @@ module.exports.Identifier = (path, printer) => {
     
     const typeAnnotation = path.get('typeAnnotation');
     
-    maybeParenOpen(path, printer);
-    
     for (const decorator of maybeDecorators(path)) {
         traverse(decorator);
         print(' ');
@@ -30,6 +24,4 @@ module.exports.Identifier = (path, printer) => {
     write(name);
     maybe.write(optional, '?');
     traverse(typeAnnotation);
-    
-    maybeParenClose(path, printer);
-};
+});

package/lib/tokenize/statements/block-statement/block-statement.js

@@ -21,6 +21,13 @@ const isFirstStatement = (path) => path.node.body[0];
 const isFirstDirective = (path) => path.node.directives?.[0];
 const isMethodOrArrow = (path) => isArrowFunctionExpression(path) || isObjectMethod(path);
 
+const parentIfWithoutElse = ({parentPath}) => {
+    if (!parentPath.isIfStatement())
+        return false;
+    
+    return !parentPath.node.alternate;
+};
+
 module.exports.BlockStatement = {
     print(path, {indent, maybe, write, traverse}, semantics) {
         const body = path.get('body');
@@ -77,7 +84,7 @@ function shouldAddNewlineAfter(path) {
     if (insideIfWithNoBody(path))
         return false;
     
-    if (path.parentPath.isIfStatement() && path.find(isMethodOrArrow))
+    if (parentIfWithoutElse(path) && path.find(isMethodOrArrow))
         return true;
     
     if (parentPath.isStatement() && !path.node.body.length && !isNext(parentPath))

package/lib/tokenize/typescript/function/ts-function-type.js

@@ -2,19 +2,15 @@
 
 const {printParams} = require('../../expressions/function/params');
 const {printReturnType} = require('./print-return-type');
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = require('../../expressions/unary-expression/parens');
 
-module.exports.TSFunctionType = (path, printer, semantics) => {
+const {maybeParens} = require('../../expressions/function/parens');
+
+module.exports.TSFunctionType = maybeParens((path, printer, semantics) => {
     const {print} = printer;
     
-    maybeParenOpen(path, printer);
     printParams(path, printer, semantics);
     print.space();
     print('=>');
     print.space();
     printReturnType(path, printer);
-    maybeParenClose(path, printer);
-};
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",