@putout/printer 17.11.0 → 17.13.0

package/ChangeLog

@@ -1,3 +1,17 @@
+2026.03.04, v17.13.0
+
+feature:
+- 4af358d @putout/printer: type-checker: expression
+- e3da216 @putout/printer: type-checker: improve dsl
+- 93986ce @putout/printer: type checker: add
+- 6a86e86 @putout/printer: type-checker: add
+
+2026.03.03, v17.12.0
+
+feature:
+- aa951ef @putout/printer: IfStatement: trailing comments
+- 3c15683 @putout/printer: isParentBlock: reuse
+
 2026.03.03, v17.11.0
 
 feature:

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

@@ -1,4 +1,8 @@
 import {maybeParens} from '#maybe-parens';
+import {
+    isParentBlock,
+    isParentProgram,
+} from '#is';
 import {condition} from './maybe-parens-condition.js';
 import {printSeparator} from './print-separator.js';
 import {
@@ -8,8 +12,6 @@ import {
     printLeadingCommentBlock,
 } from './assignment-expression-comments.js';
 
-const isInsideBlock = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
-
 export const AssignmentExpression = maybeParens({
     checkParens: false,
     condition,
@@ -25,7 +27,7 @@ export const AssignmentExpression = maybeParens({
         printSeparator(path, printer);
         print('__right');
         
-        if (isInsideBlock(path)) {
+        if (isParentBlock(path) || isParentProgram(path)) {
             print(';');
             print.breakline();
         }

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

@@ -1,22 +1,18 @@
 import {types} from '@putout/babel';
-import {isNext} from '#is';
+import {
+    hasBody,
+    isInsideTSModuleBlock,
+    isNext,
+} from '#is';
 import {markAfter} from '#mark';
 import {maybeDeclare} from '../../maybe/maybe-declare.js';
 import {parseComments} from '../../comment/comment.js';
 import {maybeDecorators} from '../../maybe/maybe-decorators.js';
 
-const isInsideTSModuleBlock = (path) => {
-    return isTSModuleBlock(path.parentPath.parentPath);
-};
-
-const {
-    isFunction,
-    isTSModuleBlock,
-} = types;
+const {isFunction} = types;
 
 const isInsideExport = ({parentPath}) => parentPath.isExportDeclaration();
 const isFunctionLike = (path) => isFunction(path.parentPath.parentPath);
-const hasBody = ({node}) => node.body.body.length;
 
 const classVisitor = maybeDecorators((path, printer, semantics) => {
     const {

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

@@ -1,21 +1,36 @@
 import {types} from '@putout/babel';
-import {isNext, isNextParent} from '#is';
 import {printParams} from '#print-params';
 import {markAfter} from '#mark';
-
-const not = (fn) => (...a) => !fn(...a);
-const notInsideExportDefaultWithBody = not(isInsideExportDefaultWithBody);
+import {
+    isInsideTSModuleBlock,
+    isNext,
+    isNextParent,
+} from '#is';
+import {createTypeChecker} from '../../type-checker/type-checker.js';
 
 const {
     isAssignmentExpression,
-    isTSModuleBlock,
-    isBlockStatement,
     isExportNamedDeclaration,
     isExpressionStatement,
     isFunctionDeclaration,
-    isExportDefaultDeclaration,
 } = types;
 
+const hasFnBody = ({node}) => node.body.body.length;
+
+const isInsideExportDefaultWithBody = createTypeChecker([
+    '-: parentPath -> !ExportDefaultDeclaration',
+    ['+', hasFnBody],
+]);
+
+const isInsideBlockLike = createTypeChecker([
+    ['+', isInsideTSModuleBlock],
+    '-: parentPath -> !BlockStatement',
+    ['+: -> !', hasFnBody],
+]);
+
+const not = (fn) => (...a) => !fn(...a);
+const notInsideExportDefaultWithBody = not(isInsideExportDefaultWithBody);
+
 const isInsideNamedExport = ({parentPath}) => isExportNamedDeclaration(parentPath);
 
 export const FunctionDeclaration = {
@@ -51,7 +66,7 @@ export const FunctionDeclaration = {
         print.space();
         print('__body');
     },
-    afterSatisfy: () => [isNext, isNextParent, isInsideBlockStatement],
+    afterSatisfy: () => [isNext, isNextParent, isInsideBlockLike],
     after(path, {indent, maybe}) {
         if (isNextAssign(path) || isNextFunction(path) || isNext(path))
             indent();
@@ -74,22 +89,3 @@ const isNextAssign = (path) => {
     
     return isAssignmentExpression(next.node.expression);
 };
-
-function isInsideBlockStatement(path) {
-    const {parentPath} = path;
-    
-    if (isTSModuleBlock(parentPath.parentPath))
-        return true;
-    
-    if (!isBlockStatement(parentPath))
-        return false;
-    
-    return !path.node.body.body.length;
-}
-
-function isInsideExportDefaultWithBody(path) {
-    if (!isExportDefaultDeclaration(path.parentPath))
-        return false;
-    
-    return path.node.body.body.length;
-}

package/lib/tokenize/is.js

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from './type-checker/type-checker.js';
 
 const {
     isStringLiteral,
@@ -12,10 +13,24 @@ const {
     isObjectExpression,
     isLabeledStatement,
     isTryStatement,
+    isProgram,
+    isBlockStatement,
+    isTSModuleBlock,
 } = types;
 
-export const isParentProgram = (path) => path.parentPath?.isProgram();
-export const isParentBlock = (path) => path.parentPath.isBlockStatement();
+export const isParentProgram = (path) => isProgram(path.parentPath);
+export const isParentBlock = (path) => isBlockStatement(path.parentPath);
+
+export const isParentBlockLike = createTypeChecker('path.parentPath', [
+    'Program',
+    'BlockStatement',
+    'TSModuleBlock',
+    'SwitchCase',
+]);
+
+export const isInsideTSModuleBlock = ({parentPath}) => {
+    return isTSModuleBlock(parentPath?.parentPath);
+};
 
 export const isNext = (path) => {
     const next = path.getNextSibling();
@@ -26,6 +41,10 @@ export const isNext = (path) => {
     return !next.isEmptyStatement();
 };
 
+export const hasBody = ({node}) => node.body.body.length;
+
+export const hasEmptyBody = (path) => !path.node.body.length;
+
 export const isNextTry = (path) => {
     return isTryStatement(path.getNextSibling());
 };

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

@@ -6,6 +6,7 @@ import {
     isLast,
     exists,
     satisfy,
+    isParentBlock,
 } from '#is';
 import {parseComments} from '../../comment/comment.js';
 import {insideIfWithNoBody} from './inside-if-with-no-body.js';
@@ -18,7 +19,6 @@ const {
     isFunctionDeclaration,
     isExportDeclaration,
     isDoWhileStatement,
-    isBlockStatement,
     isArrayExpression,
 } = types;
 
@@ -127,7 +127,6 @@ const NEWLINE = true;
 const NO_NEWLINE = false;
 
 const isInsideDoWhile = ({parentPath}) => isDoWhileStatement(parentPath);
-const isInsideBlock = ({parentPath}) => isBlockStatement(parentPath);
 
 const isNoNewline = satisfy([
     isInsideDoWhile,
@@ -136,7 +135,7 @@ const isNoNewline = satisfy([
 ]);
 
 function shouldAddNewlineAfter(path) {
-    if (isInsideBlock(path))
+    if (isParentBlock(path))
         return NEWLINE;
     
     if (isNoNewline(path))

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

@@ -1,6 +1,8 @@
-import {isNext, isInsideIf} from '#is';
-
-const isInsideBlock = (path) => path.parentPath.isBlockStatement();
+import {
+    isNext,
+    isInsideIf,
+    isParentBlock,
+} from '#is';
 
 export const DebuggerStatement = {
     print(path, {print, indent}) {
@@ -9,7 +11,7 @@ export const DebuggerStatement = {
     },
     afterSatisfy: () => [
         isNext,
-        isInsideBlock,
+        isParentBlock,
         isInsideIf,
     ],
     after(path, {print}) {

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

@@ -1,5 +1,5 @@
 import {types} from '@putout/babel';
-import {isNext} from '#is';
+import {isNext, isParentBlock} from '#is';
 
 const {isBlockStatement} = types;
 
@@ -12,13 +12,18 @@ export const printTrailingCommentBlock = (path, printer, semantics, {printCommen
 };
 
 export const printTrailingCommentLine = (path, printer, semantics, {printComment}) => {
+    const hasNext = isNext(path);
     const {consequent} = path.node;
     const consequentIsBlock = isBlockStatement(consequent);
-    const {print, maybe} = printer;
+    const {print} = printer;
     
     print.indent();
-    maybe.print.space(!consequentIsBlock);
+    
+    if (!hasNext && !consequentIsBlock)
+        print.space();
     
     printComment();
-    maybe.print.newline(consequentIsBlock);
+    
+    if (hasNext || isParentBlock(path))
+        print.newline();
 };

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

@@ -1,10 +1,11 @@
 import {types} from '@putout/babel';
+import {markAfter} from '#mark';
 import {
     exists,
     isNext,
     isInsideIf,
+    hasEmptyBody,
 } from '#is';
-import {markAfter} from '#mark';
 import {
     printTrailingCommentBlock,
     printTrailingCommentLine,
@@ -42,8 +43,6 @@ const isInsideNestedBody = ({parentPath}) => {
     return parentPath.parentPath.type === 'BlockStatement';
 };
 
-const isEmptyBody = (path) => !path.node.body.length;
-
 const isLastEmptyInsideBody = (path) => {
     const {parentPath} = path;
     
@@ -85,7 +84,7 @@ export const IfStatement = {
             print(consequent);
             
             if (isInsideIf(path.parentPath) || isInsideNestedBody(path))
-                maybe.print.newline(isEmptyBody(consequent));
+                maybe.print.newline(hasEmptyBody(consequent));
         } else {
             const is = !isEmptyConsequent(path);
             

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

@@ -1,5 +1,9 @@
 import {types} from '@putout/babel';
-import {isNext, isNextTry} from '#is';
+import {
+    isNext,
+    isNextTry,
+    isParentBlock,
+} from '#is';
 
 const {isExpressionStatement} = types;
 
@@ -34,6 +38,7 @@ const isNextExpression = (path) => {
 };
 
 export const CatchClause = (path, {print, maybe}) => {
+    const {parentPath} = path;
     const param = path.get('param');
     const body = path.get('body');
     
@@ -50,9 +55,5 @@ export const CatchClause = (path, {print, maybe}) => {
     }
     
     print(body);
-    maybe.print.newline(isInsideBlock(path));
+    maybe.print.newline(isParentBlock(parentPath));
 };
-
-function isInsideBlock(path) {
-    return path.parentPath.parentPath.isBlockStatement();
-}

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

@@ -6,21 +6,28 @@ import {
     isNewlineBetweenSiblings,
     exists,
     noTrailingComment,
+    isParentBlockLike,
 } from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {isConcatenation} from '../../expressions/binary-expression/concatenate.js';
 import {parseLeadingComments} from '../../comment/comment.js';
 import {maybeDeclare} from '../../maybe/maybe-declare.js';
+import {createTypeChecker} from '../../type-checker/type-checker.js';
 
 const {isExportDeclaration} = types;
 
 const isParentTSModuleBlock = (path) => path.parentPath.isTSModuleBlock();
-const isParentBlock = (path) => /Program|BlockStatement|Export|LabeledStatement/.test(path.parentPath.type);
-const isInsideBlock = (path) => /^(Program|BlockStatement|TSModuleBlock|SwitchCase)$/.test(path.parentPath.type);
 const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
 const isFirstInSwitch = (path) => path.parentPath.get('consequent.0') === path;
 const isParentIf = (path) => path.parentPath.isIfStatement();
 
+const isParentBlock = createTypeChecker('path.parentPath', [
+    'Program',
+    'BlockStatement',
+    'ExportNamedDeclaration',
+    'LabeledStatement',
+]);
+
 export const VariableDeclaration = {
     beforeIf: shouldAddNewlineBefore,
     before(path, {print}) {
@@ -29,7 +36,7 @@ export const VariableDeclaration = {
     print: maybeDeclare((path, {maybe, store, write, traverse, print, indent}, semantics) => {
         const {maxVariablesInOneLine} = semantics;
         
-        maybe.indent(isInsideBlock(path));
+        maybe.indent(isParentBlockLike(path));
         
         write(path.node.kind);
         maybeSpaceAfterKeyword(path, {

package/lib/tokenize/type-checker/type-checker.js

@@ -0,0 +1,130 @@
+import {jessy} from 'jessy';
+
+const {isArray} = Array;
+
+const isString = (a) => typeof a === 'string';
+const isFn = (a) => typeof a === 'function';
+
+const equal = (not, a, b) => {
+    if (!isString(b))
+        return false;
+    
+    if (not)
+        return a !== b;
+    
+    return a === b;
+};
+
+const exec = (fn, not, a) => {
+    if (!isFn(fn))
+        return false;
+    
+    const result = fn(a);
+    
+    if (not)
+        return !result;
+    
+    return result;
+};
+
+export const createTypeChecker = (deepness, typeNames) => {
+    if (!typeNames) {
+        typeNames = deepness;
+        deepness = '';
+    }
+    
+    const tuples = parseTypeNames(typeNames);
+    
+    return (path) => {
+        let i = deepness.split('.').length;
+        
+        while (--i)
+            path = path?.parentPath;
+        
+        if (!path)
+            return false;
+        
+        for (const [operation, typeName] of tuples) {
+            const [result, selector, not] = parseOperation(operation);
+            let currentPath = path;
+            
+            if (selector)
+                currentPath = jessy(selector, path);
+            
+            const {type} = currentPath;
+            
+            if (equal(not, type, typeName))
+                return result;
+            
+            if (exec(typeName, not, currentPath))
+                return result;
+        }
+        
+        return false;
+    };
+};
+
+const parseOperation = (operation) => {
+    const [result, command] = operation.split(':');
+    const parsedResult = parseResult(result);
+    
+    if (!command)
+        return [parsedResult, '', ''];
+    
+    const [selector, not] = command.split(' -> ');
+    
+    return [parsedResult, selector.trim(), not];
+};
+
+const parseResult = (a) => a === '+';
+
+function parseTypeNames(typeNames) {
+    const tuples = [];
+    
+    if (isArray(typeNames)) {
+        for (const typeName of typeNames) {
+            if (isArray(typeName)) {
+                tuples.push(typeName);
+                continue;
+            }
+            
+            if (isString(typeName) && typeName.includes(' -> ')) {
+                const tuple = createTuple(typeName);
+                tuples.push(tuple);
+                continue;
+            }
+            
+            tuples.push(['+', typeName]);
+        }
+        
+        return tuples;
+    }
+    
+    for (const typeName of typeNames.include) {
+        tuples.push(['+', typeName]);
+    }
+    
+    for (const typeName of typeNames.exclude) {
+        tuples.push(['-', typeName]);
+    }
+    
+    return tuples;
+}
+
+function createTuple(typeName) {
+    const afterSplit = typeName.split(' ');
+    const typeWithNot = afterSplit.pop();
+    const array = typeWithNot.split('!');
+    const operation = afterSplit.join(' ');
+    
+    if (array.length === 1)
+        return [
+            `${operation} `,
+            typeWithNot,
+        ];
+    
+    return [
+        `${operation} !`,
+        array[1],
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "17.11.0",
+  "version": "17.13.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -38,6 +38,7 @@
     "@putout/operate": "^15.0.0",
     "@putout/operator-json": "^3.1.0",
     "fullstore": "^4.0.0",
+    "jessy": "^5.0.0",
     "just-snake-case": "^3.2.0",
     "parse-import-specifiers": "^1.0.1",
     "rendy": "^5.0.0"