@putout/printer 18.19.0 → 18.20.0

package/ChangeLog

@@ -1,3 +1,8 @@
+2026.06.20, v18.20.0
+
+feature:
+- b38b9939 @putout/printer: new line before leading Comment, after CallExpression
+
 2026.06.19, v18.19.0
 
 feature:

package/lib/tokenize/statements/expression-statement/after-if.js

@@ -1,14 +1,27 @@
+import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
 import {
     hasTrailingComment,
-    isCoupleLines,
     isInsideBlock,
+    isInsideReturn,
     isLast,
     isNext,
     isParentLast,
     satisfy,
+    exists,
+    isCoupleLines,
 } from '#is';
 
+const {
+    isCallExpression,
+    isAssignmentExpression,
+    isArrayExpression,
+    isStringLiteral,
+    isTemplateLiteral,
+    isExpressionStatement,
+    isStatement,
+} = types;
+
 function isNotLastOrParentLast(path) {
     return !isLast(path) && !isParentLast(path);
 }
@@ -37,16 +50,80 @@ const isBeforeElse = createTypeChecker([
     ['+: parentPath.node.alternate -> +'],
 ]);
 
-const hasTrailingCommentNotCoupleLines = createTypeChecker([
-    ['-: -> !', hasTrailingComment],
-    ['+: -> !', isCoupleLines],
-]);
+const isNextCallWithLeadingComments = (path) => {
+    const next = path.getNextSibling();
+    
+    if (!exists(next))
+        return false;
+    
+    if (!path.node.trailingComments)
+        return false;
+    
+    if (isStatement(next) && isCoupleLines(path))
+        return true;
+    
+    if (!isExpressionStatement(next))
+        return false;
+    
+    const {expression} = path.node;
+    
+    if (isCallExpression(expression))
+        return true;
+    
+    const nextExpression = next.get('expression');
+    
+    return isCallExpression(nextExpression);
+};
+
+function isNextWithLeadingComments(path) {
+    const next = path.getNextSibling();
+    const {expression} = path.node;
+    
+    if (!path.node.trailingComments)
+        return true;
+    
+    if (isAssignmentExpression(expression))
+        return true;
+    
+    return !exists(next);
+}
+
+export function isNextSimpleWithLeadingComments(path) {
+    const next = path.getNextSibling();
+    
+    if (!hasTrailingComment(path))
+        return false;
+    
+    if (!isExpressionStatement(next))
+        return false;
+    
+    const {expression} = next.node;
+    
+    if (isStringLiteral(expression))
+        return true;
+    
+    if (isTemplateLiteral(expression))
+        return true;
+    
+    return isArrayExpression(next.node.expression);
+}
+
+function isAssignWithTrailingComments(path) {
+    const {expression} = path.node;
+    
+    if (!isAssignmentExpression(expression))
+        return false;
+    
+    return hasTrailingComment(path);
+}
 
 export const afterIf = createTypeChecker([
+    ['-', isInsideReturn],
     ['-', isTopParentLast],
-    ['-', hasTrailingCommentNotCoupleLines],
+    ['+', isNextCallWithLeadingComments],
+    ['-: -> !', isNextWithLeadingComments],
+    ['+', isAssignWithTrailingComments],
+    ['-: node.trailingComments.length -> +'],
     ['+', satisfyAfter],
     ['+', isBeforeElse],
-    ['-: -> !', hasTrailingComment],
-    ['+', isLast],
 ]);

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

@@ -2,11 +2,8 @@ import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
 import {
     isNext,
-    isLast,
     isNewlineBetweenSiblings,
     noTrailingComment,
-    hasTrailingComment,
-    isCoupleLines,
     isInsideReturn,
     callWithNext,
     hasLeadingComment,
@@ -15,7 +12,10 @@ import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
 } from './comments.js';
-import {afterIf} from './after-if.js';
+import {
+    afterIf,
+    isNextSimpleWithLeadingComments,
+} from './after-if.js';
 import {beforeIf} from './before-if.js';
 
 const {isIfStatement} = types;
@@ -30,12 +30,6 @@ const isNextToAssignmentCall = createTypeChecker([
     ['+', callWithNext(isCallInsideExpression)],
 ]);
 
-const isBreaklineAfter = createTypeChecker([
-    ['-: -> !', hasTrailingComment],
-    ['-: -> !', isLast],
-    ['+', isCoupleLines],
-]);
-
 const isNextStatementWithBlockComment = createTypeChecker([
     '-: node.expression -> !CallExpression',
     '-: node.expression.arguments.0 -> !CallExpression',
@@ -80,13 +74,11 @@ export const ExpressionStatement = {
     },
     afterIf,
     after(path, {print, maybe, store}) {
-        maybe.print.breakline(isBreaklineAfter(path));
+        maybe.indent(isIndentAfter(path));
         
-        if (isInsideReturn(path))
-            return;
+        if (!isNextSimpleWithLeadingComments(path))
+            print.newline();
         
-        maybe.indent(isIndentAfter(path));
-        print.newline();
         maybe.markAfter(store(), path);
     },
 };

package/package.json

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