@putout/printer 1.9.0 → 1.10.0

package/ChangeLog

@@ -1,3 +1,15 @@
+2023.03.28, v1.10.0
+
+feature:
+- c2f1d12 @putout/printer: add new pluginObject type of plugin
+
+2023.03.28, v1.9.1
+
+feature:
+- 063bb53 @putout/printer: improve support of AST witout parent File
+- d6fd09d @putout/printer: add support of trailingComments
+- a323b20 @putout/printer: shouldAddNewlineAfter
+
 2023.03.27, v1.9.0
 
 feature:

package/lib/print-tokens/cook.js

@@ -3,7 +3,7 @@
 module.exports.cook = (tokens) => {
     const cookedTokens = [];
     
-    for (const [i, {value}] of tokens.entries()) {
+    for (const {value} of tokens) {
         cookedTokens.push(value);
     }
     

package/lib/printer.js

@@ -5,5 +5,7 @@ const {printTokens} = require('./print-tokens');
 
 module.exports.print = (ast, overrides) => {
     const tokens = tokenize(ast, overrides);
-    return printTokens(tokens);
+    const result = printTokens(tokens);
+    
+    return result;
 };

package/lib/tokenize/comments.js

@@ -3,15 +3,11 @@
 const {isFirst} = require('./is');
 const {markBefore} = require('./mark');
 
-module.exports.parseComments = (path, {print, indent, maybe}) => {
+module.exports.parseLeadingComments = (path, {print, indent}) => {
     const {leadingComments} = path.node;
     
-    if (leadingComments)
-        parseLeadingComments(path, {print, indent, maybe});
-};
-
-function parseLeadingComments(path, {print, indent}) {
-    const {leadingComments} = path.node;
+    if (!leadingComments || !leadingComments.length)
+        return;
     
     if (shouldAddNewlineBefore(path))
         print.linebreak();
@@ -22,6 +18,7 @@ function parseLeadingComments(path, {print, indent}) {
         if (type === 'CommentLine') {
             print(`//${value}`);
             print.newline();
+            
             continue;
         }
         
@@ -36,9 +33,24 @@ function parseLeadingComments(path, {print, indent}) {
             continue;
         }
     }
-}
+};
+
+module.exports.parseTrailingComments = (path, {print}) => {
+    const {trailingComments} = path.node;
+    
+    if (!trailingComments || !trailingComments.length)
+        return;
+    
+    for (const {type, value} of trailingComments) {
+        if (type === 'CommentLine') {
+            print.space();
+            print(`//${value}`);
+            
+            continue;
+        }
+    }
+};
 
 function shouldAddNewlineBefore(path) {
     return path.isStatement() && !isFirst(path);
 }
-

package/lib/tokenize/debug.js

@@ -1,10 +1,13 @@
 'use strict';
 
+const {stringify} = JSON;
+
 const {TYPES} = require('../types');
 const toSnakeCase = require('just-snake-case');
 const {
     LOG,
     LOG_ALL,
+    LOG_TOKENS,
     DEBUG,
 } = process.env;
 const {codeFrameColumns} = require('@babel/code-frame');
@@ -19,23 +22,30 @@ module.exports.createDebug = (tokens) => (a) => {
     });
 };
 
-module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => (chunk) => {
+module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => ({type, value}) => {
+    if (LOG_TOKENS) {
+        console.log(codeFrameColumns(stringify({type, value}), {}, {
+            highlightCode: true,
+        }));
+        return;
+    }
+    
     if (LOG_ALL) {
-        console.log(codeFrameColumns(chunk, {}, {
+        console.log(codeFrameColumns(value, {}, {
             highlightCode: true,
         }));
         return;
     }
     
     if (LOG) {
-        if (chunk === newline) {
+        if (value === newline) {
             console.log(codeFrameColumns(store(), {}, {
                 highlightCode: true,
             }));
             return;
         }
         
-        store(chunk);
+        store(value);
     }
 };
 

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

@@ -5,61 +5,59 @@ const {
     hasPrevNewline,
 } = require('../mark');
 
-module.exports.OptionalCallExpression = (path, {indent, print, maybe}) => {
-    return CallExpression(path, {
-        indent,
-        print,
-        maybe,
-    });
-};
-
 const {entries} = Object;
 
-module.exports.CallExpression = CallExpression;
-
-function CallExpression(path, {indent, print, maybe}) {
-    const isParentCall = toLong(path) && path.parentPath.isCallExpression();
-    
-    if (isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath)) {
+const CallExpression = {
+    beforeIf(path) {
+        return isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath);
+    },
+    before(path, {print}) {
         print.breakline();
-    }
-    
-    print('__callee');
-    
-    if (path.node.optional)
-        print('?.');
-    
-    print('(');
-    
-    const args = path.get('arguments');
-    const n = args.length - 1;
-    
-    maybe.indent.inc(isParentCall);
-    
-    for (const [i, arg] of entries(args)) {
-        if (isParentCall) {
-            print.newline();
-            indent();
-        }
+    },
+    print(path, {indent, print, maybe}) {
+        const isParentCall = toLong(path) && path.parentPath.isCallExpression();
         
-        print(arg);
+        print('__callee');
+        
+        if (path.node.optional)
+            print('?.');
+        
+        print('(');
+        
+        const args = path.get('arguments');
+        const n = args.length - 1;
+        
+        maybe.indent.inc(isParentCall);
+        
+        for (const [i, arg] of entries(args)) {
+            if (isParentCall) {
+                print.newline();
+                indent();
+            }
+            
+            print(arg);
+            
+            if (isParentCall) {
+                print(',');
+                continue;
+            }
+            
+            maybe.print(i < n, ', ');
+        }
         
         if (isParentCall) {
-            print(',');
-            continue;
+            indent.dec();
+            print.newline();
+            print.indent();
         }
         
-        maybe.print(i < n, ', ');
-    }
-    
-    if (isParentCall) {
-        indent.dec();
-        print.newline();
-        print.indent();
-    }
-    
-    print(')');
-}
+        print(')');
+    },
+};
+
+module.exports.OptionalCallExpression = CallExpression;
+
+module.exports.CallExpression = CallExpression;
 
 function isNewLineBefore({parentPath}) {
     if (!parentPath.isExpressionStatement())

package/lib/tokenize/expressions/class-declaration.js

@@ -1,14 +1,7 @@
 'use strict';
 
 const {entries} = Object;
-
-const isFirst = (path) => path.node === path.parentPath.node.body[0];
-
 module.exports.ClassDeclaration = (path, {maybe, print, indent}) => {
-    if (!isFirst(path)) {
-        print.breakline();
-    }
-    
     indent();
     print('class ');
     print('__id');

package/lib/tokenize/expressions/index.js

@@ -4,13 +4,19 @@ const functions = require('./functions');
 const unaryExpressions = require('./unary-expressions');
 const memberExpressions = require('./member-expressions');
 const {ClassDeclaration} = require('./class-declaration');
+
 const {
     CallExpression,
     OptionalCallExpression,
 } = require('./call-expression');
 
 const {NewExpression} = require('./new-expression');
-const {ObjectExpression} = require('./object-expression');
+
+const {
+    ObjectExpression,
+    ObjectProperty,
+} = require('./object-expression');
+
 const {ObjectPattern} = require('./object-pattern');
 const {AssignmentExpression} = require('./assignment-expression');
 const {ArrayExpression} = require('./array-expression');
@@ -20,10 +26,12 @@ const {RestElement} = require('./rest-element');
 const {SpreadElement} = require('./spread-element');
 const {SequenceExpression} = require('./sequence-expression');
 const {TaggedTemplateExpression} = require('./tagged-template-expression');
+
 const {
     BinaryExpression,
     LogicalExpression,
 } = require('./binary-expression');
+
 const {ConditionalExpression} = require('./conditional-expression');
 
 module.exports = {
@@ -42,6 +50,7 @@ module.exports = {
     LogicalExpression,
     OptionalCallExpression,
     ObjectExpression,
+    ObjectProperty,
     ObjectPattern,
     RestElement,
     SpreadElement,

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

@@ -3,6 +3,7 @@
 const {isCoupleLines} = require('../is');
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
+
 const isForOf = (path) => {
     if (path.parentPath.isForOfStatement())
         return true;
@@ -20,7 +21,6 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
     
     maybe.print(parens, '(');
     print('{');
-    
     maybe.print(manyLines, '\n');
     
     for (const property of properties) {
@@ -36,8 +36,6 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
             continue;
         }
         
-        const {shorthand, computed} = property.node;
-        
         maybe.indent(manyLines);
         
         if (property.isObjectMethod()) {
@@ -45,25 +43,36 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
             continue;
         }
         
-        maybe.print(computed, '[');
-        print(property.get('key'));
-        maybe.print(computed, ']');
-        
-        if (!shorthand) {
-            print(': ');
-            print(property.get('value'));
-        }
-        
-        maybe.print(manyLines, ',\n');
+        print(property);
+        maybe.print.newline(manyLines);
     }
     
     indent.dec();
-    
     maybe.indent(manyLines);
     print('}');
     maybe.print.newline(path.parentPath.isLogicalExpression());
     maybe.print(parens, ')');
 };
+
+module.exports.ObjectProperty = (path, {print, maybe}) => {
+    const {
+        shorthand,
+        computed,
+    } = path.node;
+    const manyLines = !isOneLine(path.parentPath);
+    
+    maybe.print(computed, '[');
+    print('__key');
+    maybe.print(computed, ']');
+    
+    if (!shorthand) {
+        print(': ');
+        print('__value');
+    }
+    
+    maybe.print(manyLines, ',');
+};
+
 function isOneLine(path) {
     const isCall = path.parentPath.isCallExpression();
     const {length} = path.get('properties');

package/lib/tokenize/is.js

@@ -1,15 +1,29 @@
 'use strict';
 
+const isParentProgram = (path) => path.parentPath?.isProgram();
+const isParentBlock = (path) => path.parentPath.isBlockStatement();
+const isNext = (path) => path.getNextSibling().node;
+const isNextParent = (path) => path.parentPath.getNextSibling().node;
+const isLast = (path) => isParentProgram(path) && !isNext(path);
+
 module.exports.isFirst = (path) => path.node === path.parentPath.node.body[0];
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
-module.exports.isNext = (path) => path.getNextSibling().node;
-module.exports.isProgramParent = (path) => path.parentPath?.isProgram();
-module.exports.isNextParent = (path) => path.parentPath.getNextSibling().node;
-module.exports.isNextBlock = (path) => path.getNextSibling().isBlockStatement();
+module.exports.isNext = isNext;
+module.exports.isNextParent = isNextParent;
+module.exports.isParentProgram = isParentProgram;
+module.exports.isParentBlock = isParentBlock;
+module.exports.isLast = isLast;
+module.exports.isParentLast = (path) => isLast(path.parentPath);
+module.exports.isCoupleLines = isCoupleLines;
+module.exports.isNextCoupleLines = isNextCoupleLines;
 
-module.exports.isCoupleLines = (path) => {
+function isCoupleLines(path) {
     const start = path.node?.loc?.start?.line;
     const end = path.node?.loc?.end?.line;
     
     return end > start;
-};
+}
+
+function isNextCoupleLines(path) {
+    return isCoupleLines(path.getNextSibling());
+}

package/lib/tokenize/literals/index.js

@@ -4,24 +4,24 @@ const {TemplateLiteral} = require('./template-literal');
 
 module.exports = {
     TemplateLiteral,
-    NumericLiteral(path, {print}) {
+    NumericLiteral(path, {write}) {
         const {
             raw,
             extra,
         } = path.node;
         
-        print(raw || extra.raw);
+        write(raw || extra.raw);
     },
-    BooleanLiteral(path, {print}) {
-        print(path.node.value);
+    BooleanLiteral(path, {write}) {
+        write(path.node.value);
     },
-    StringLiteral(path, {print}) {
+    StringLiteral(path, {write}) {
         const {
             raw,
             value,
         } = path.node;
         
-        print(raw || `'${value}'`);
+        write(raw || `'${value}'`);
     },
     Identifier(path, {write}) {
         write(path.node.name);
@@ -29,7 +29,10 @@ module.exports = {
     RegExpLiteral(path, {print}) {
         print(path.node.raw);
     },
-    NullLiteral(path, {print}) {
-        print('null');
+    NullLiteral(path, {write}) {
+        write('null');
+    },
+    MetaProperty(path, {write}) {
+        write('import.meta');
     },
 };

package/lib/tokenize/mark.js

@@ -5,6 +5,7 @@ const WATER_MARK_AFTER = '__putout_newline_after';
 
 module.exports.markBefore = markBefore;
 module.exports.markAfter = markAfter;
+module.exports.maybeMarkAfter = (a, path) => a && markAfter(path);
 
 function markBefore(path) {
     path[WATER_MARK_BEFORE] = true;

package/lib/tokenize/maybe.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const isFn = (a) => typeof a === 'function';
+
+const {
+    isProgram,
+    isFile,
+    File,
+    ExpressionStatement,
+    Program,
+} = require('@babel/types');
+
+const maybeProgram = (ast) => isProgram(ast) ? ast : Program([
+    ExpressionStatement(ast),
+]);
+
+module.exports.maybeFile = (ast) => isFile(ast) ? ast : File(maybeProgram(ast));
+
+module.exports.maybePlugin = (plugin, path, printer) => {
+    if (isFn(plugin))
+        return plugin(path, printer);
+    
+    return objectPlugin(plugin, path, printer);
+};
+
+function objectPlugin(plugin, path, printer) {
+    const {
+        print,
+        split,
+        before = split,
+        beforeIf,
+        after = split,
+        afterIf,
+    } = plugin;
+    
+    if (beforeIf?.(path, printer)) {
+        before(path, printer);
+    }
+    
+    print(path, printer);
+    
+    if (afterIf?.(path, printer)) {
+        after(path, printer);
+    }
+}

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

@@ -2,8 +2,9 @@
 
 const {
     isNext,
-    isProgramParent,
+    isParentProgram,
 } = require('../is');
+
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
 module.exports.BlockStatement = (path, {indent, maybe, print}) => {
@@ -38,7 +39,7 @@ module.exports.BlockStatement = (path, {indent, maybe, print}) => {
 function shouldAddNewlineAfter(path) {
     const {parentPath} = path;
     
-    if (!isNext(path) && !isNext(path.parentPath) && isProgramParent(path.parentPath))
+    if (!isNext(path) && !isNext(path.parentPath) && isParentProgram(path.parentPath))
         return false;
     
     if (parentPath.isStatement() && !path.node.body.length && !isNext(parentPath))

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

@@ -0,0 +1,23 @@
+'use strict';
+
+const {
+    isNext,
+    isParentBlock,
+    isNextParent,
+} = require('../is');
+
+module.exports.BreakStatement = {
+    split(path, {print}) {
+        print.newline();
+    },
+    print(path, {print, indent}) {
+        indent();
+        print('break;');
+    },
+    afterIf(path) {
+        if (!isNext(path) && !isParentBlock(path) && !isNextParent(path))
+            return false;
+        
+        return true;
+    },
+};

package/lib/tokenize/statements/export-default-declaration.js

@@ -1,19 +1,7 @@
 'use strict';
 
-const {isFirst} = require('../is');
-
 module.exports.ExportDefaultDeclaration = (path, {print}) => {
-    if (shouldAddNewlineBefore(path))
-        print.newline();
-    
     print('export default ');
     print('__declaration');
     print(';');
 };
-
-function shouldAddNewlineBefore(path) {
-    if (isFirst(path))
-        return false;
-    
-    return true;
-}

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

@@ -1,53 +1,78 @@
 'use strict';
 
-const {
-    markBefore,
-    markAfter,
-    hasPrevNewline,
-} = require('../mark');
-
 const {
     isNext,
-    isProgramParent,
-    isNextParent,
-
+    isParentProgram,
+    isLast,
+    isParentBlock,
+    isCoupleLines,
+    isNextCoupleLines,
+    isParentLast,
 } = require('../is');
 
-module.exports.ExpressionStatement = (path, {indent, print}) => {
-    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewlineBefore(path) && !hasPrevNewline(path)) {
-        print.breakline();
-        markBefore(path);
-    }
+const isNextDifferent = (path) => {
+    const next = path.getNextSibling();
     
-    indent();
-    print('__expression');
-    print(';');
-    
-    if (isNext(path) || isNextParent(path) || path.parentPath.isBlockStatement() && !isProgramParent(path)) {
-        print.newline();
-    }
+    if (!next.isExpressionStatement())
+        return true;
     
-    if (shouldAddNewLineAfter(path)) {
+    return next.node.expression.type !== path.node.expression.type;
+};
+
+module.exports.ExpressionStatement = {
+    print(path, {indent, print, maybe, store}) {
+        indent();
+        print('__expression');
+        print(';');
+        
+        if (shouldBreakline(path)) {
+            print.newline();
+            maybe.indent(isNext(path));
+            store(true);
+        }
+    },
+    afterIf(path) {
+        return shouldAddNewLineAfter(path);
+    },
+    after(path, {print, maybe, store}) {
         print.newline();
-        markAfter(path);
-    }
+        maybe.markAfter(store(), path);
+    },
 };
 
-function shouldAddNewLineAfter(path) {
-    if (!isNext(path))
+function shouldBreakline(path) {
+    if (isLast(path) || isParentLast(path))
         return false;
     
-    if (isStrictMode(path) || isCoupleLinesExpression(path))
+    if (!isNext(path) && isParentBlock(path))
+        return false;
+    
+    if (path.parentPath.get('body') === path)
+        return true;
+    
+    if (isStrictMode(path))
+        return true;
+    
+    if (isNext(path) && isNextDifferent(path) && path.parentPath.node.body?.length > 2)
+        return true;
+    
+    if (isCoupleLines(path) || isNextCoupleLines(path))
         return true;
     
     return false;
 }
 
-function isCoupleLinesExpression(path) {
-    const start = path.node.loc?.start?.line;
-    const end = path.node.loc?.end?.line;
+function shouldAddNewLineAfter(path) {
+    if (isLast(path) || isParentLast(path))
+        return false;
+    
+    if (isParentBlock(path) && !isParentProgram(path))
+        return true;
+    
+    if (isNext(path))
+        return true;
     
-    return end > start;
+    return false;
 }
 
 function isStrictMode(path) {
@@ -60,22 +85,3 @@ function isStrictMode(path) {
     
     return value === 'use strict';
 }
-
-function isFirst(path) {
-    return path.node === path.parentPath.node.body[0];
-}
-
-function shouldAddNewlineBefore(path) {
-    const prev = path.getPrevSibling();
-    
-    if (prev.isVariableDeclaration())
-        return false;
-    
-    if (prev.isIfStatement())
-        return false;
-    
-    if (isStrictMode(prev))
-        return false;
-    
-    return true;
-}

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

@@ -1,36 +1,42 @@
 'use strict';
 
-module.exports.ForStatement = (path, {print, maybe, indent}) => {
-    const {
-        test,
-        update,
-        body,
-    } = path.node;
-    
-    print('for (');
-    print('__init');
-    print(';');
-    maybe.print(test, ' ');
-    print('__test');
-    print(';');
-    maybe.print(update, ' ');
-    print('__update');
-    print(')');
-    
-    if (body.body) {
-        print(' ');
-        print('__body');
-        print.newline();
+const {isLast} = require('../is');
+
+module.exports.ForStatement = {
+    print(path, {print, maybe, indent}) {
+        const {
+            test,
+            update,
+            body,
+        } = path.node;
         
-        return;
-    }
-    
-    if (!body.body) {
-        print.newline();
-        indent.inc();
-        print('__body');
-        indent.dec();
+        print('for (');
+        print('__init');
+        print(';');
+        maybe.print(test, ' ');
+        print('__test');
+        print(';');
+        maybe.print(update, ' ');
+        print('__update');
+        print(')');
+        
+        if (body.body) {
+            print(' ');
+            print('__body');
+        } else {
+            print.newline();
+            indent.inc();
+            print('__body');
+            indent.dec();
+        }
+    },
+    after(path, {print}) {
         print.newline();
-    }
+    },
+    afterIf(path) {
+        if (isLast(path))
+            return false;
+        
+        return true;
+    },
 };
-

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

@@ -4,9 +4,8 @@ const {hasPrevNewline, markAfter} = require('../mark');
 const {isFirst} = require('../is');
 
 module.exports.IfStatement = (path, {indent, print}) => {
-    if (!isFirst(path) && !hasPrevNewline(path)) {
-        print.indent();
-        print.newline();
+    if (shouldAddNewlineBefore(path)) {
+        print.linebreak();
     }
     
     indent();
@@ -31,6 +30,7 @@ module.exports.IfStatement = (path, {indent, print}) => {
         print(' else ');
         print(alternate);
     } else if (alternate.node) {
+        print.breakline();
         print('else');
         print.newline();
         indent.inc();
@@ -48,3 +48,6 @@ module.exports.IfStatement = (path, {indent, print}) => {
     markAfter(path);
 };
 
+function shouldAddNewlineBefore(path) {
+    return !isFirst(path) && !hasPrevNewline(path);
+}

package/lib/tokenize/statements/import-declarations.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {markAfter} = require('../mark');
 const {entries} = Object;
 
 module.exports.ImportDeclaration = (path, {print, maybe}) => {
@@ -27,5 +28,16 @@ module.exports.ImportDeclaration = (path, {print, maybe}) => {
     print('__source');
     print(';');
     print.newline();
+    
+    if (shouldAddNewlineAfter(path)) {
+        print.newline();
+        markAfter(path);
+    }
 };
 
+function shouldAddNewlineAfter(path) {
+    if (path.getNextSibling().isImportDeclaration())
+        return false;
+    
+    return true;
+}

package/lib/tokenize/statements/index.js

@@ -15,6 +15,7 @@ const {WhileStatement} = require('./while-statement');
 const {SwitchStatement} = require('./switch-statement');
 const {ForInStatement} = require('./for-in-statement');
 const {ExportDefaultDeclaration} = require('./export-default-declaration');
+const {BreakStatement} = require('./break-statement');
 
 module.exports = {
     ...importDeclarations,
@@ -34,11 +35,7 @@ module.exports = {
     },
     SwitchStatement,
     ...TryStatements,
-    BreakStatement(path, {print, indent}) {
-        indent();
-        print('break;');
-        print.newline();
-    },
+    BreakStatement,
     ContinueStatement(path, {indent, print}) {
         indent();
         print('continue;');

package/lib/tokenize/statements/variable-declaration.js

@@ -3,9 +3,8 @@
 const {
     isNext,
     isCoupleLines,
-    isNextBlock,
-
 } = require('../is');
+
 const {
     hasPrevNewline,
     markAfter,
@@ -26,6 +25,7 @@ module.exports.VariableDeclaration = (path, {maybe, print}) => {
     maybe.print(initPath.node, ' = ');
     print(initPath);
     maybe.print(isParentBlock(path), ';');
+    
     let wasNewline = false;
     
     if (isParentBlock(path) && isNext(path)) {
@@ -44,9 +44,6 @@ function shouldAddNewlineAfter(path) {
     if (!isNext(path) && path.parentPath.isBlockStatement())
         return true;
     
-    if (isNextBlock(path))
-        return false;
-    
     if (isLast(path))
         return false;
     
@@ -61,7 +58,6 @@ function shouldAddNewlineAfter(path) {
     
     return false;
 }
-
 const isLast = (path) => path.parentPath.isProgram() && !isNext(path);
 
 function shouldAddNewlineBefore(path) {
@@ -81,15 +77,6 @@ function shouldAddNewlineBefore(path) {
     
     if (isCoupleLines(path))
         return true;
-    
-    const nextPath = path.getNextSibling();
-    const nextNextPath = nextPath.getNextSibling();
-    const twoNext = nextPath.node && nextNextPath.node;
-    
-    if (!twoNext)
-        return false;
-    
-    return true;
 }
 
 function isFirst(path) {
@@ -103,4 +90,3 @@ const isNextAssign = (path) => {
     
     return nextPath.get('expression').isAssignmentExpression();
 };
-

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

@@ -1,5 +1,7 @@
 'use strict';
 
+const {isLast} = require('../is');
+
 module.exports.WhileStatement = (path, {print, indent}) => {
     print('while (');
     print('__test');
@@ -15,5 +17,14 @@ module.exports.WhileStatement = (path, {print, indent}) => {
         indent.dec();
     }
     
-    print.linebreak();
+    if (shouldAddNewlineAfter(path)) {
+        print.linebreak();
+    }
 };
+
+function shouldAddNewlineAfter(path) {
+    if (isLast(path))
+        return false;
+    
+    return true;
+}

package/lib/tokenize/tokenize.js

@@ -1,19 +1,30 @@
 'use strict';
 
+const fullstore = require('fullstore');
+
 const isObject = (a) => a && typeof a === 'object';
 const babelTraverse = require('@babel/traverse').default;
 const expressions = require('./expressions');
 const statements = require('./statements');
 const literals = require('./literals');
 const {TYPES} = require('../types');
-const {createDebug, createLog} = require('./debug');
+const {maybeFile, maybePlugin} = require('./maybe');
+
+const {
+    createDebug,
+    createLog,
+} = require('./debug');
 
 const {
     maybeMarkAfter,
     maybeMarkBefore,
 } = require('./mark');
 
-const {parseComments} = require('./comments');
+const {
+    parseLeadingComments,
+    parseTrailingComments,
+} = require('./comments');
+
 const isString = (a) => typeof a === 'string';
 const {assign} = Object;
 
@@ -32,13 +43,11 @@ function initFormat(format) {
         indent: '    ',
     };
 }
-
 const createAddToken = (tokens) => {
     const log = createLog();
+    
     return (token) => {
-        const {value} = token;
-        
-        log(value);
+        log(token);
         tokens.push(token);
     };
 };
@@ -130,6 +139,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
         debug,
         traverse,
         maybe,
+        store: fullstore(),
     };
     
     const currentTraversers = {
@@ -137,7 +147,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
         ...overrides.visitors,
     };
     
-    babelTraverse(ast, {
+    babelTraverse(maybeFile(ast), {
         Program(path) {
             traverse(path);
             path.stop();
@@ -179,8 +189,10 @@ module.exports.tokenize = (ast, overrides = {}) => {
         if (!currentTraverse)
             throw Error(`Node type '${type}' is not supported yet: '${path}'`);
         
-        parseComments(path, printer);
-        currentTraverse(path, printer);
+        parseLeadingComments(path, printer);
+        maybePlugin(currentTraverse, path, printer);
+        parseTrailingComments(path, printer);
+        
         debug(path.type);
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",
@@ -30,6 +30,7 @@
     "@babel/parser": "^7.19.0",
     "@babel/traverse": "^7.21.2",
     "@babel/types": "^7.21.3",
+    "fullstore": "^3.0.0",
     "just-snake-case": "^3.2.0"
   },
   "keywords": [
@@ -49,7 +50,6 @@
     "eslint-plugin-putout": "^17.0.0",
     "estree-to-babel": "^5.0.1",
     "just-kebab-case": "^4.2.0",
-    "lerna": "^6.0.1",
     "madrun": "^9.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.0.0",

package/rules/putout-plugin-apply-computed-print/index.js

@@ -1,11 +1,21 @@
 'use strict';
 
+const {assign} = Object;
+
 module.exports.report = () => `Use print('__path') instead of path.get(__path)`;
 
 module.exports.replace = () => ({
     'print(path.get(__a))': ({__a}) => {
-        __a.value = '__' + __a.value;
+        const {
+            raw,
+            value,
+        } = __a;
+        
+        assign(__a, {
+            value: `__${value}`,
+            raw: raw.replace(value, `__${value}`),
+        });
+        
         return 'print(__a)';
     },
 });
-