@putout/printer 18.26.0 → 18.28.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.07.03, v18.28.0
+
+feature:
+- 64e0fc9a @putout/printer: ExpressionStatement: comments
+
+2026.07.02, v18.27.0
+
+feature:
+- 45cb944d @putout/printer: type-checker: types
+
 2026.06.27, v18.26.0
 
 feature:

package/lib/tokenize/comments/comments-printer/comments-printer.js

@@ -1,6 +1,18 @@
 const createPrintCommentLine = (fn, value) => () => fn(`//${value}`);
 const createPrintCommentBlock = (fn, value) => () => fn(`/*${value}*/\n`);
 
+const isCommentBlock = (node) => node.type === 'CommentBlock';
+const isCommentLine = (node) => node.type === 'CommentLine';
+
+function isSameLine(path, loc) {
+    const {node} = path;
+    
+    if (!node.loc)
+        return false;
+    
+    return node.loc.start.line === loc.start.line;
+}
+
 export const hasTrailingCommentsPrinter = (currentTraverse) => {
     const {
         printTrailingCommentBlock,
@@ -38,8 +50,10 @@ export const printLeadingComments = (path, printer, semantics, {currentTraverse}
     
     const n = leadingComments.length - 1;
     
-    for (const [index, {type, value}] of leadingComments.entries()) {
-        if (type === 'CommentLine') {
+    for (const [index, comment] of leadingComments.entries()) {
+        const {value} = comment;
+        
+        if (isCommentLine(comment)) {
             printLeadingCommentLine?.(path, printer, semantics, {
                 index,
                 printComment: createPrintCommentLine(print, value),
@@ -48,7 +62,7 @@ export const printLeadingComments = (path, printer, semantics, {currentTraverse}
             continue;
         }
         
-        if (type === 'CommentBlock')
+        if (isCommentBlock(comment))
             printLeadingCommentBlock?.(path, printer, semantics, {
                 index,
                 printComment: createPrintCommentBlock(print, value),
@@ -69,20 +83,24 @@ export const printTrailingComments = (path, printer, semantics, {currentTraverse
     
     const n = trailingComments.length - 1;
     
-    for (const [index, {type, value}] of trailingComments.entries()) {
-        if (type === 'CommentLine') {
+    for (const [index, comment] of trailingComments.entries()) {
+        const {loc, value} = comment;
+        
+        if (isCommentLine(comment)) {
             printTrailingCommentLine?.(path, printer, semantics, {
                 index,
                 printComment: createPrintCommentLine(print, value),
                 isLast: index === n,
+                isSameLine: isSameLine(path, loc),
             });
             continue;
         }
         
-        if (type === 'CommentBlock')
-            printTrailingCommentBlock?.(path, printer, semantics, {
-                index,
-                printComment: createPrintCommentBlock(print, value),
-            });
+        isCommentBlock(comment);
+        
+        printTrailingCommentBlock?.(path, printer, semantics, {
+            index,
+            printComment: createPrintCommentBlock(print, value),
+        });
     }
 };

package/lib/tokenize/comments/parse-trailing-comments.js

@@ -13,7 +13,6 @@ import {
 const {
     isDecorator,
     isMemberExpression,
-    isExpressionStatement,
     isCallExpression,
 } = types;
 
@@ -77,9 +76,6 @@ function isCommentOnNextLine(path) {
     if (next.node && line < next.node.loc?.start.line)
         return false;
     
-    if (!loc)
-        return true;
-    
     const startLine = loc.start.line;
     const endLine = loc.end.line;
     const isNextLine = line === startLine + 1 && line === endLine + 1;
@@ -154,15 +150,7 @@ export const parseTrailingComments = (path, printer, semantics, {currentTraverse
 };
 
 function isPrevCall(path) {
-    const prev = path.getPrevSibling();
-    
-    if (isExpressionStatement(prev))
-        return false;
-    
     const {expression} = path.node;
     
-    if (!isCallExpression(expression))
-        return false;
-    
-    return !isCallExpression(expression.arguments[0]);
+    return isCallExpression(expression);
 }

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

@@ -1,5 +1,11 @@
 import {types} from '@putout/babel';
-import {hasTrailingComment} from '#is';
+import {createTypeChecker} from '#type-checker';
+import {
+    isNext,
+    hasTrailingComment,
+    isInsideBlock,
+    callWithNext,
+} from '#is';
 
 const {
     isBlockStatement,
@@ -25,6 +31,33 @@ export const printLeadingCommentLine = (path, printer, semantics, {index, isLast
         print.indent();
 };
 
+export const printTrailingCommentLine = (path, printer, semantics, {isSameLine, printComment}) => {
+    const {print} = printer;
+    
+    if (isSameLine)
+        print.space();
+    else if (!isNext(path) || isNextNotSimple(path))
+        print.breakline();
+    else
+        print.indent();
+    
+    printComment();
+    
+    if (isNext(path) || isInsideBlock(path))
+        print.newline();
+};
+
+const isSimple = createTypeChecker([
+    '+: node.expression -> StringLiteral',
+    '+: node.expression -> TemplateLiteral',
+    '+: node.expression -> ArrayExpression',
+    '+: node.expression -> BooleanLiteral',
+]);
+
+const isNextNotSimple = createTypeChecker([
+    ['+: -> !', callWithNext(isSimple)],
+]);
+
 export const printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
     const {indent} = printer;
     const prev = path.getPrevSibling();
@@ -37,3 +70,12 @@ export const printLeadingCommentBlock = (path, printer, semantics, {printComment
     
     printComment();
 };
+
+export const printTrailingCommentBlock = (path, printer, semantics, {printComment}) => {
+    const {print} = printer;
+    
+    if (isNext(path))
+        print.breakline();
+    
+    printComment();
+};

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

@@ -7,18 +7,20 @@ import {
     isInsideReturn,
     callWithNext,
     hasLeadingComment,
+    hasTrailingComment,
 } from '#is';
+import {afterIf} from './after-if.js';
+import {beforeIf} from './before-if.js';
 import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
+    printTrailingCommentLine,
+    printTrailingCommentBlock,
 } from './comments.js';
-import {afterIf} from './after-if.js';
-import {beforeIf} from './before-if.js';
 
 const {isIfStatement} = types;
 
 const isCallInsideExpression = createTypeChecker([
-    '-: -> !ExpressionStatement',
     '+: node.expression -> CallExpression',
 ]);
 
@@ -27,12 +29,6 @@ const isNextToAssignmentCall = createTypeChecker([
     ['+', callWithNext(isCallInsideExpression)],
 ]);
 
-const isNextStatementWithBlockComment = createTypeChecker([
-    '-: node.expression -> !CallExpression',
-    '-: node.expression.arguments.0 -> !CallExpression',
-    '+: node.trailingComments.0 -> CommentBlock',
-]);
-
 const isBreakline = createTypeChecker([
     ['+', isNewlineBetweenSiblings],
     ['+', callWithNext(isIfStatement)],
@@ -40,8 +36,8 @@ const isBreakline = createTypeChecker([
 
 const isIndent = createTypeChecker([
     noTrailingComment,
+    callWithNext(isIfStatement),
     isNextToAssignmentCall,
-    isNextStatementWithBlockComment,
 ]);
 
 export const isIndentAfter = createTypeChecker([
@@ -52,6 +48,8 @@ export const isIndentAfter = createTypeChecker([
 export const ExpressionStatement = {
     printLeadingCommentLine,
     printLeadingCommentBlock,
+    printTrailingCommentLine,
+    printTrailingCommentBlock,
     beforeIf,
     before(path, {indent}) {
         indent();
@@ -73,18 +71,13 @@ export const ExpressionStatement = {
     after(path, {print, maybe, store}) {
         maybe.indent(isIndentAfter(path));
         
-        if (!isNextSimpleWithLeadingComments(path))
+        if (isNewlineAfter(path))
             print.newline();
         
         maybe.markAfter(store(), path);
     },
 };
 
-export const isNextSimpleWithLeadingComments = callWithNext(createTypeChecker([
-    ['-: -> !', hasLeadingComment],
-    ['-: -> !ExpressionStatement'],
-    ['+: node.expression -> TemplateLiteral'],
-    ['+: node.expression -> ArrayExpression'],
-    ['+: node.expression -> BooleanLiteral'],
-    ['+: node.expression -> StringLiteral'],
-]));
+export const isNewlineAfter = createTypeChecker([
+    ['+: -> !', hasTrailingComment],
+]);

package/lib/tokenize/type-checker/instrument.d.ts

@@ -0,0 +1,19 @@
+type TypeChecker = (path: unknown, options?: Record<string, unknown>) => boolean;
+type CoverageEntry = {
+    covered: Set<number>;
+    typeNames: unknown[];
+};
+type InstrumentOverride = {
+    env?: {
+        TYPE_CHECK?: string;
+        [key: string]: unknown;
+    };
+    coverage?: Map<string, CoverageEntry>;
+    instrumentName?: string;
+    [key: string]: unknown;
+};
+
+export function instrument(typeNames: unknown[], fn: TypeChecker, overrides?: InstrumentOverride): TypeChecker;
+
+export function getCoverage(): Map<string, CoverageEntry>;
+

package/lib/tokenize/type-checker/report.d.ts

@@ -0,0 +1,7 @@
+type CoverageEntry = {
+    covered: Set<number>;
+    typeNames: unknown[];
+};
+
+export function report(coverage: Map<string, CoverageEntry>): [number, string];
+

package/lib/tokenize/type-checker/type-checker.d.ts

@@ -0,0 +1,9 @@
+type TypeChecker = (path: unknown, options?: Record<string, unknown>) => boolean;
+type TypeCheckerOverride = {
+    instrumentCoverage?: (typeNames: unknown[], fn: TypeChecker, overrides?: Record<string, unknown>) => TypeChecker;
+    instrumentName?: string;
+    [key: string]: unknown;
+};
+
+export function createTypeChecker(typeNames: unknown[], overrides?: TypeCheckerOverride): TypeChecker;
+

package/lib/tokenize/type-checker/when-tests-ends.d.ts

@@ -0,0 +1,15 @@
+type WhenTestsEndsOverride = {
+    log?: (message: string) => void;
+    getCoverage?: () => Map<string, {
+        covered: Set<number>;
+        typeNames: unknown[];
+    }>;
+    report?: (coverage: Map<string, {
+        covered: Set<number>;
+        typeNames: unknown[];
+    }>) => [number, string];
+    [key: string]: unknown;
+};
+
+export function whenTestsEnds(overrides?: WhenTestsEndsOverride): number;
+

package/package.json

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

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "compilerOptions": {
-        "moduleResolution": "nodenext",
-        "module": "NodeNext",
-        "target": "es2015",
-        "skipLibCheck": true
-    },
-    "include": ["lib/printer.d.ts", "test/*.ts"]
-}