diff --git a/src/index.ts b/src/index.ts
index b70b5100c..b591d7b7e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -12,7 +12,10 @@ import { locEnd, locStart } from './slang-utils/loc.js';
 import { hasPrettierIgnore } from './slang-utils/has-prettier-ignore.js';
 
 import type {
+  AstPath,
+  Doc,
   Parser,
+  ParserOptions,
   Printer,
   RequiredOptions,
   SupportLanguage
@@ -77,7 +80,12 @@ const slangPrinter: Printer<PrintableNode | undefined> = {
   handleComments,
   isBlockComment,
   massageAstNode,
-  print: slangPrint,
+  print: slangPrint as (
+    path: AstPath<PrintableNode | undefined>,
+    options: ParserOptions<PrintableNode | undefined>,
+    print: (path: AstPath<PrintableNode | undefined>) => Doc,
+    args?: unknown
+  ) => Doc,
   hasPrettierIgnore,
   printComment
 };
diff --git a/src/slang-nodes/AbicoderPragma.ts b/src/slang-nodes/AbicoderPragma.ts
index bd0ba81df..f09e565bf 100644
--- a/src/slang-nodes/AbicoderPragma.ts
+++ b/src/slang-nodes/AbicoderPragma.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { AbicoderVersion } from './AbicoderVersion.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class AbicoderPragma extends SlangNode {
@@ -19,7 +19,7 @@ export class AbicoderPragma extends SlangNode {
     this.updateMetadata(this.version);
   }
 
-  print(path: AstPath<AbicoderPragma>, print: PrintFunction): Doc {
-    return ['abicoder ', path.call(print, 'version')];
+  print(print: PrintFunction): Doc {
+    return ['abicoder ', print('version')];
   }
 }
diff --git a/src/slang-nodes/AdditiveExpression.ts b/src/slang-nodes/AdditiveExpression.ts
index 27c142161..36d2d55c9 100644
--- a/src/slang-nodes/AdditiveExpression.ts
+++ b/src/slang-nodes/AdditiveExpression.ts
@@ -57,8 +57,8 @@ export class AdditiveExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<AdditiveExpression>,
     print: PrintFunction,
+    path: AstPath<AdditiveExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printAdditiveExpression(this, path, print, options);
diff --git a/src/slang-nodes/AndExpression.ts b/src/slang-nodes/AndExpression.ts
index 09c7af03d..457a32db6 100644
--- a/src/slang-nodes/AndExpression.ts
+++ b/src/slang-nodes/AndExpression.ts
@@ -37,8 +37,8 @@ export class AndExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<AndExpression>,
     print: PrintFunction,
+    path: AstPath<AndExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printLogicalOperation(this, path, print, options);
diff --git a/src/slang-nodes/ArrayExpression.ts b/src/slang-nodes/ArrayExpression.ts
index 56f5b0701..16f62faa6 100644
--- a/src/slang-nodes/ArrayExpression.ts
+++ b/src/slang-nodes/ArrayExpression.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { ArrayValues } from './ArrayValues.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class ArrayExpression extends SlangNode {
     this.updateMetadata(this.items);
   }
 
-  print(path: AstPath<ArrayExpression>, print: PrintFunction): Doc {
-    return ['[', path.call(print, 'items'), ']'];
+  print(print: PrintFunction): Doc {
+    return ['[', print('items'), ']'];
   }
 }
diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts
index f9a3b3278..ee8a1ddee 100644
--- a/src/slang-nodes/ArrayTypeName.ts
+++ b/src/slang-nodes/ArrayTypeName.ts
@@ -5,7 +5,7 @@ import { TypeName } from './TypeName.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -35,7 +35,7 @@ export class ArrayTypeName extends SlangNode {
     this.updateMetadata(this.operand, this.index);
   }
 
-  print(path: AstPath<ArrayTypeName>, print: PrintFunction): Doc {
-    return [path.call(print, 'operand'), '[', path.call(print, 'index'), ']'];
+  print(print: PrintFunction): Doc {
+    return [print('operand'), '[', print('index'), ']'];
   }
 }
diff --git a/src/slang-nodes/ArrayValues.ts b/src/slang-nodes/ArrayValues.ts
index 55cd588ca..4c60e7038 100644
--- a/src/slang-nodes/ArrayValues.ts
+++ b/src/slang-nodes/ArrayValues.ts
@@ -26,7 +26,7 @@ export class ArrayValues extends SlangNode {
     );
   }
 
-  print(path: AstPath<ArrayValues>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<ArrayValues>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/AssemblyFlags.ts b/src/slang-nodes/AssemblyFlags.ts
index 0e651cee4..aebe6682d 100644
--- a/src/slang-nodes/AssemblyFlags.ts
+++ b/src/slang-nodes/AssemblyFlags.ts
@@ -25,7 +25,7 @@ export class AssemblyFlags extends SlangNode {
     );
   }
 
-  print(path: AstPath<AssemblyFlags>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<AssemblyFlags>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/AssemblyFlagsDeclaration.ts b/src/slang-nodes/AssemblyFlagsDeclaration.ts
index ef20d8f03..8cee9a1f9 100644
--- a/src/slang-nodes/AssemblyFlagsDeclaration.ts
+++ b/src/slang-nodes/AssemblyFlagsDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { AssemblyFlags } from './AssemblyFlags.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class AssemblyFlagsDeclaration extends SlangNode {
     this.updateMetadata(this.flags);
   }
 
-  print(path: AstPath<AssemblyFlagsDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'flags'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('flags'), ')'];
   }
 }
diff --git a/src/slang-nodes/AssemblyStatement.ts b/src/slang-nodes/AssemblyStatement.ts
index 4c0681f5d..f1e1d8950 100644
--- a/src/slang-nodes/AssemblyStatement.ts
+++ b/src/slang-nodes/AssemblyStatement.ts
@@ -6,7 +6,7 @@ import { AssemblyFlagsDeclaration } from './AssemblyFlagsDeclaration.js';
 import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -37,12 +37,12 @@ export class AssemblyStatement extends SlangNode {
     this.updateMetadata(this.label, this.flags, this.body);
   }
 
-  print(path: AstPath<AssemblyStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return joinExisting(' ', [
       'assembly',
-      path.call(print, 'label'),
-      path.call(print, 'flags'),
-      path.call(print, 'body')
+      print('label'),
+      print('flags'),
+      print('body')
     ]);
   }
 }
diff --git a/src/slang-nodes/AssignmentExpression.ts b/src/slang-nodes/AssignmentExpression.ts
index e5f4b3e81..68fe94173 100644
--- a/src/slang-nodes/AssignmentExpression.ts
+++ b/src/slang-nodes/AssignmentExpression.ts
@@ -5,7 +5,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -36,14 +36,11 @@ export class AssignmentExpression extends SlangNode {
     this.updateMetadata(this.leftOperand, this.rightOperand);
   }
 
-  print(path: AstPath<AssignmentExpression>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
-      path.call(print, 'leftOperand'),
+      print('leftOperand'),
       ` ${this.operator}`,
-      printAssignmentRightSide(
-        path.call(print, 'rightOperand'),
-        this.rightOperand
-      )
+      printAssignmentRightSide(print('rightOperand'), this.rightOperand)
     ];
   }
 }
diff --git a/src/slang-nodes/BitwiseAndExpression.ts b/src/slang-nodes/BitwiseAndExpression.ts
index e3e4aaffd..1dd312e7c 100644
--- a/src/slang-nodes/BitwiseAndExpression.ts
+++ b/src/slang-nodes/BitwiseAndExpression.ts
@@ -53,8 +53,8 @@ export class BitwiseAndExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<BitwiseAndExpression>,
     print: PrintFunction,
+    path: AstPath<BitwiseAndExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printBitwiseAndExpression(this, path, print, options);
diff --git a/src/slang-nodes/BitwiseOrExpression.ts b/src/slang-nodes/BitwiseOrExpression.ts
index c635a83af..38371ee1d 100644
--- a/src/slang-nodes/BitwiseOrExpression.ts
+++ b/src/slang-nodes/BitwiseOrExpression.ts
@@ -63,8 +63,8 @@ export class BitwiseOrExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<BitwiseOrExpression>,
     print: PrintFunction,
+    path: AstPath<BitwiseOrExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printBitwiseOrExpression(this, path, print, options);
diff --git a/src/slang-nodes/BitwiseXorExpression.ts b/src/slang-nodes/BitwiseXorExpression.ts
index 33a69d6eb..220b1f4a1 100644
--- a/src/slang-nodes/BitwiseXorExpression.ts
+++ b/src/slang-nodes/BitwiseXorExpression.ts
@@ -53,8 +53,8 @@ export class BitwiseXorExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<BitwiseXorExpression>,
     print: PrintFunction,
+    path: AstPath<BitwiseXorExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printBitwiseXorExpression(this, path, print, options);
diff --git a/src/slang-nodes/Block.ts b/src/slang-nodes/Block.ts
index fc7bd9ce4..368188803 100644
--- a/src/slang-nodes/Block.ts
+++ b/src/slang-nodes/Block.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { Statements } from './Statements.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class Block extends SlangNode {
     this.updateMetadata(this.statements);
   }
 
-  print(path: AstPath<Block>, print: PrintFunction): Doc {
-    return ['{', path.call(print, 'statements'), '}'];
+  print(print: PrintFunction): Doc {
+    return ['{', print('statements'), '}'];
   }
 }
diff --git a/src/slang-nodes/CallOptions.ts b/src/slang-nodes/CallOptions.ts
index 7cdfa1538..f8f2c7ae5 100644
--- a/src/slang-nodes/CallOptions.ts
+++ b/src/slang-nodes/CallOptions.ts
@@ -29,8 +29,8 @@ export class CallOptions extends SlangNode {
   }
 
   print(
-    path: AstPath<CallOptions>,
     print: PrintFunction,
+    path: AstPath<CallOptions>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printSeparatedList(path.map(print, 'items'), {
diff --git a/src/slang-nodes/CallOptionsExpression.ts b/src/slang-nodes/CallOptionsExpression.ts
index 5116993b3..d4f3b36e1 100644
--- a/src/slang-nodes/CallOptionsExpression.ts
+++ b/src/slang-nodes/CallOptionsExpression.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 import { CallOptions } from './CallOptions.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,7 +31,7 @@ export class CallOptionsExpression extends SlangNode {
     this.updateMetadata(this.operand, this.options);
   }
 
-  print(path: AstPath<CallOptionsExpression>, print: PrintFunction): Doc {
-    return [path.call(print, 'operand'), '{', path.call(print, 'options'), '}'];
+  print(print: PrintFunction): Doc {
+    return [print('operand'), '{', print('options'), '}'];
   }
 }
diff --git a/src/slang-nodes/CatchClause.ts b/src/slang-nodes/CatchClause.ts
index 5399df174..06422b031 100644
--- a/src/slang-nodes/CatchClause.ts
+++ b/src/slang-nodes/CatchClause.ts
@@ -4,7 +4,7 @@ import { CatchClauseError } from './CatchClauseError.js';
 import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -30,7 +30,7 @@ export class CatchClause extends SlangNode {
     this.updateMetadata(this.error, this.body);
   }
 
-  print(path: AstPath<CatchClause>, print: PrintFunction): Doc {
-    return ['catch ', path.call(print, 'error'), path.call(print, 'body')];
+  print(print: PrintFunction): Doc {
+    return ['catch ', print('error'), print('body')];
   }
 }
diff --git a/src/slang-nodes/CatchClauseError.ts b/src/slang-nodes/CatchClauseError.ts
index b2fd74669..88019555c 100644
--- a/src/slang-nodes/CatchClauseError.ts
+++ b/src/slang-nodes/CatchClauseError.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { ParametersDeclaration } from './ParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -37,11 +37,7 @@ export class CatchClauseError extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<CatchClauseError>, print: PrintFunction): Doc {
-    return [
-      path.call(print, 'name'),
-      group(path.call(print, 'parameters')),
-      ' '
-    ];
+  print(print: PrintFunction): Doc {
+    return [print('name'), group(print('parameters')), ' '];
   }
 }
diff --git a/src/slang-nodes/CatchClauses.ts b/src/slang-nodes/CatchClauses.ts
index 31f1edea8..12be56552 100644
--- a/src/slang-nodes/CatchClauses.ts
+++ b/src/slang-nodes/CatchClauses.ts
@@ -29,7 +29,7 @@ export class CatchClauses extends SlangNode {
     this.updateMetadata(...this.items);
   }
 
-  print(path: AstPath<CatchClauses>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<CatchClauses>): Doc {
     return join(' ', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/ConditionalExpression.ts b/src/slang-nodes/ConditionalExpression.ts
index 6cd2fcaf3..0fed3fb3e 100644
--- a/src/slang-nodes/ConditionalExpression.ts
+++ b/src/slang-nodes/ConditionalExpression.ts
@@ -28,7 +28,7 @@ function experimentalTernaries(
 
   // If the `condition` breaks into multiple lines, we add parentheses,
   // unless it already is a `TupleExpression`.
-  const operand = path.call(print, 'operand');
+  const operand = print('operand');
   const operandDoc = group([
     node.operand.kind === NonterminalKind.TupleExpression
       ? operand
@@ -41,7 +41,7 @@ function experimentalTernaries(
   // `trueExpression`.
   const trueExpressionDoc = indent([
     isNestedAsTrueExpression ? hardline : line,
-    path.call(print, 'trueExpression')
+    print('trueExpression')
   ]);
 
   const groupId = Symbol('Slang.ConditionalExpression.trueExpression');
@@ -58,7 +58,7 @@ function experimentalTernaries(
       ? ' '.repeat(tabWidth - 1)
       : ' ';
 
-  const falseExpression = path.call(print, 'falseExpression');
+  const falseExpression = print('falseExpression');
   const falseExpressionDoc = [
     isNested ? hardline : line,
     ':',
@@ -81,7 +81,7 @@ function traditionalTernaries(
   print: PrintFunction
 ): Doc {
   return group([
-    path.call(print, 'operand'),
+    print('operand'),
     indent([
       // Nested trueExpression and falseExpression are always printed in a new
       // line
@@ -89,10 +89,10 @@ function traditionalTernaries(
         ? hardline
         : line,
       '? ',
-      path.call(print, 'trueExpression'),
+      print('trueExpression'),
       line,
       ': ',
-      path.call(print, 'falseExpression')
+      print('falseExpression')
     ])
   ]);
 }
@@ -156,8 +156,8 @@ export class ConditionalExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<ConditionalExpression>,
     print: PrintFunction,
+    path: AstPath<ConditionalExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return options.experimentalTernaries
diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts
index e53cf4c6f..5a2cfa2f1 100644
--- a/src/slang-nodes/ConstantDefinition.ts
+++ b/src/slang-nodes/ConstantDefinition.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -36,13 +36,13 @@ export class ConstantDefinition extends SlangNode {
     this.updateMetadata(this.typeName, this.value);
   }
 
-  print(path: AstPath<ConstantDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
-      path.call(print, 'typeName'),
+      print('typeName'),
       ' constant ',
-      path.call(print, 'name'),
+      print('name'),
       ' =',
-      printAssignmentRightSide(path.call(print, 'value'), this.value),
+      printAssignmentRightSide(print('value'), this.value),
       ';'
     ];
   }
diff --git a/src/slang-nodes/ConstructorAttributes.ts b/src/slang-nodes/ConstructorAttributes.ts
index aad88b906..f24edf5b0 100644
--- a/src/slang-nodes/ConstructorAttributes.ts
+++ b/src/slang-nodes/ConstructorAttributes.ts
@@ -31,7 +31,7 @@ export class ConstructorAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<ConstructorAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<ConstructorAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/ConstructorDefinition.ts b/src/slang-nodes/ConstructorDefinition.ts
index ff84c5da6..03c921112 100644
--- a/src/slang-nodes/ConstructorDefinition.ts
+++ b/src/slang-nodes/ConstructorDefinition.ts
@@ -6,7 +6,7 @@ import { ConstructorAttributes } from './ConstructorAttributes.js';
 import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -41,7 +41,7 @@ export class ConstructorDefinition extends SlangNode {
     this.updateMetadata(this.parameters, this.attributes, this.body);
   }
 
-  print(path: AstPath<ConstructorDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody('constructor', this, path, print);
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody('constructor', this, print);
   }
 }
diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts
index 44f7a507c..d601632a9 100644
--- a/src/slang-nodes/ContractDefinition.ts
+++ b/src/slang-nodes/ContractDefinition.ts
@@ -7,7 +7,7 @@ import { ContractSpecifiers } from './ContractSpecifiers.js';
 import { ContractMembers } from './ContractMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -58,17 +58,17 @@ export class ContractDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<ContractDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       group([
         this.abstractKeyword ? 'abstract ' : '',
         'contract ',
-        path.call(print, 'name'),
-        path.call(print, 'specifiers'),
+        print('name'),
+        print('specifiers'),
         this.specifiers.items.length > 0 ? '' : line,
         '{'
       ]),
-      path.call(print, 'members'),
+      print('members'),
       '}'
     ];
   }
diff --git a/src/slang-nodes/ContractMembers.ts b/src/slang-nodes/ContractMembers.ts
index 53f13032c..440510529 100644
--- a/src/slang-nodes/ContractMembers.ts
+++ b/src/slang-nodes/ContractMembers.ts
@@ -31,8 +31,8 @@ export class ContractMembers extends SlangNode {
   }
 
   print(
-    path: AstPath<ContractMembers>,
     print: PrintFunction,
+    path: AstPath<ContractMembers>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
diff --git a/src/slang-nodes/ContractSpecifiers.ts b/src/slang-nodes/ContractSpecifiers.ts
index e70fef9bb..819586bbc 100644
--- a/src/slang-nodes/ContractSpecifiers.ts
+++ b/src/slang-nodes/ContractSpecifiers.ts
@@ -32,7 +32,7 @@ export class ContractSpecifiers extends SlangNode {
     this.items.sort(sortContractSpecifiers);
   }
 
-  print(path: AstPath<ContractSpecifiers>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<ContractSpecifiers>): Doc {
     const [specifier1, specifier2] = path.map(print, 'items');
 
     if (specifier1 === undefined) return '';
diff --git a/src/slang-nodes/DecimalNumberExpression.ts b/src/slang-nodes/DecimalNumberExpression.ts
index 2ab65cde6..bc8a20628 100644
--- a/src/slang-nodes/DecimalNumberExpression.ts
+++ b/src/slang-nodes/DecimalNumberExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { NumberUnit } from './NumberUnit.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class DecimalNumberExpression extends SlangNode {
@@ -25,7 +25,7 @@ export class DecimalNumberExpression extends SlangNode {
     this.updateMetadata(this.unit);
   }
 
-  print(path: AstPath<DecimalNumberExpression>, print: PrintFunction): Doc {
-    return joinExisting(' ', [this.literal, path.call(print, 'unit')]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [this.literal, print('unit')]);
   }
 }
diff --git a/src/slang-nodes/DoWhileStatement.ts b/src/slang-nodes/DoWhileStatement.ts
index c372f958a..c4766fc7e 100644
--- a/src/slang-nodes/DoWhileStatement.ts
+++ b/src/slang-nodes/DoWhileStatement.ts
@@ -7,7 +7,7 @@ import { Statement } from './Statement.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -35,15 +35,15 @@ export class DoWhileStatement extends SlangNode {
     this.updateMetadata(this.body, this.condition);
   }
 
-  print(path: AstPath<DoWhileStatement>, print: PrintFunction): Doc {
-    const body = path.call(print, 'body');
+  print(print: PrintFunction): Doc {
+    const body = print('body');
     return [
       'do',
       this.body.kind === NonterminalKind.Block
         ? [' ', body, ' ']
         : printSeparatedItem(body, { firstSeparator: line }),
       'while (',
-      printSeparatedItem(path.call(print, 'condition')),
+      printSeparatedItem(print('condition')),
       ');'
     ];
   }
diff --git a/src/slang-nodes/ElseBranch.ts b/src/slang-nodes/ElseBranch.ts
index 48c162301..06819bca8 100644
--- a/src/slang-nodes/ElseBranch.ts
+++ b/src/slang-nodes/ElseBranch.ts
@@ -6,7 +6,7 @@ import { SlangNode } from './SlangNode.js';
 import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -32,11 +32,11 @@ export class ElseBranch extends SlangNode {
     this.updateMetadata(this.body);
   }
 
-  print(path: AstPath<ElseBranch>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'else',
       printIndentedGroupOrSpacedDocument(
-        path.call(print, 'body'),
+        print('body'),
         !isIfStatementOrBlock(this.body)
       )
     ];
diff --git a/src/slang-nodes/EmitStatement.ts b/src/slang-nodes/EmitStatement.ts
index dfb0a8c18..bce61520f 100644
--- a/src/slang-nodes/EmitStatement.ts
+++ b/src/slang-nodes/EmitStatement.ts
@@ -5,7 +5,7 @@ import { IdentifierPath } from './IdentifierPath.js';
 import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,12 +31,7 @@ export class EmitStatement extends SlangNode {
     this.updateMetadata(this.event, this.arguments);
   }
 
-  print(path: AstPath<EmitStatement>, print: PrintFunction): Doc {
-    return [
-      'emit ',
-      path.call(print, 'event'),
-      path.call(print, 'arguments'),
-      ';'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['emit ', print('event'), print('arguments'), ';'];
   }
 }
diff --git a/src/slang-nodes/EnumDefinition.ts b/src/slang-nodes/EnumDefinition.ts
index 986493b5e..08ac15689 100644
--- a/src/slang-nodes/EnumDefinition.ts
+++ b/src/slang-nodes/EnumDefinition.ts
@@ -4,7 +4,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { EnumMembers } from './EnumMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class EnumDefinition extends SlangNode {
@@ -23,13 +23,7 @@ export class EnumDefinition extends SlangNode {
     this.updateMetadata(this.members);
   }
 
-  print(path: AstPath<EnumDefinition>, print: PrintFunction): Doc {
-    return [
-      'enum ',
-      path.call(print, 'name'),
-      ' {',
-      path.call(print, 'members'),
-      '}'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['enum ', print('name'), ' {', print('members'), '}'];
   }
 }
diff --git a/src/slang-nodes/EnumMembers.ts b/src/slang-nodes/EnumMembers.ts
index 4aee04ef7..1142732d0 100644
--- a/src/slang-nodes/EnumMembers.ts
+++ b/src/slang-nodes/EnumMembers.ts
@@ -21,7 +21,7 @@ export class EnumMembers extends SlangNode {
     this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
-  print(path: AstPath<EnumMembers>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<EnumMembers>): Doc {
     return printSeparatedList(path.map(print, 'items'), {
       firstSeparator: hardline
     });
diff --git a/src/slang-nodes/EqualityExpression.ts b/src/slang-nodes/EqualityExpression.ts
index 3455c23b0..9bbdce691 100644
--- a/src/slang-nodes/EqualityExpression.ts
+++ b/src/slang-nodes/EqualityExpression.ts
@@ -50,8 +50,8 @@ export class EqualityExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<EqualityExpression>,
     print: PrintFunction,
+    path: AstPath<EqualityExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printEqualityExpression(this, path, print, options);
diff --git a/src/slang-nodes/ErrorDefinition.ts b/src/slang-nodes/ErrorDefinition.ts
index b51280b7c..4ed989bbd 100644
--- a/src/slang-nodes/ErrorDefinition.ts
+++ b/src/slang-nodes/ErrorDefinition.ts
@@ -4,7 +4,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { ErrorParametersDeclaration } from './ErrorParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -32,12 +32,7 @@ export class ErrorDefinition extends SlangNode {
     this.updateMetadata(this.members);
   }
 
-  print(path: AstPath<ErrorDefinition>, print: PrintFunction): Doc {
-    return [
-      'error ',
-      path.call(print, 'name'),
-      path.call(print, 'members'),
-      ';'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['error ', print('name'), print('members'), ';'];
   }
 }
diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts
index 16ce4a952..9e81ec7d1 100644
--- a/src/slang-nodes/ErrorParameter.ts
+++ b/src/slang-nodes/ErrorParameter.ts
@@ -6,7 +6,7 @@ import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,10 +34,7 @@ export class ErrorParameter extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<ErrorParameter>, print: PrintFunction): Doc {
-    return joinExisting(' ', [
-      path.call(print, 'typeName'),
-      path.call(print, 'name')
-    ]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [print('typeName'), print('name')]);
   }
 }
diff --git a/src/slang-nodes/ErrorParameters.ts b/src/slang-nodes/ErrorParameters.ts
index 5b63af1c5..4daa667e1 100644
--- a/src/slang-nodes/ErrorParameters.ts
+++ b/src/slang-nodes/ErrorParameters.ts
@@ -25,7 +25,7 @@ export class ErrorParameters extends SlangNode {
     );
   }
 
-  print(path: AstPath<ErrorParameters>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<ErrorParameters>): Doc {
     return this.items.length > 0
       ? printSeparatedList(path.map(print, 'items'))
       : '';
diff --git a/src/slang-nodes/ErrorParametersDeclaration.ts b/src/slang-nodes/ErrorParametersDeclaration.ts
index 3e08bd3c7..8ce8651aa 100644
--- a/src/slang-nodes/ErrorParametersDeclaration.ts
+++ b/src/slang-nodes/ErrorParametersDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { ErrorParameters } from './ErrorParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class ErrorParametersDeclaration extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<ErrorParametersDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'parameters'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('parameters'), ')'];
   }
 }
diff --git a/src/slang-nodes/EventDefinition.ts b/src/slang-nodes/EventDefinition.ts
index ab4d7bace..4af7fdcb2 100644
--- a/src/slang-nodes/EventDefinition.ts
+++ b/src/slang-nodes/EventDefinition.ts
@@ -4,7 +4,7 @@ import { EventParametersDeclaration } from './EventParametersDeclaration.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -35,11 +35,11 @@ export class EventDefinition extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<EventDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'event ',
-      path.call(print, 'name'),
-      path.call(print, 'parameters'),
+      print('name'),
+      print('parameters'),
       this.anonymousKeyword ? ' anonymous;' : ';'
     ];
   }
diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts
index b534ae336..997cd5dc9 100644
--- a/src/slang-nodes/EventParameter.ts
+++ b/src/slang-nodes/EventParameter.ts
@@ -6,7 +6,7 @@ import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -37,11 +37,11 @@ export class EventParameter extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<EventParameter>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(print, 'typeName'),
+      print('typeName'),
       this.indexedKeyword,
-      path.call(print, 'name')
+      print('name')
     ]);
   }
 }
diff --git a/src/slang-nodes/EventParameters.ts b/src/slang-nodes/EventParameters.ts
index 3d142597f..6a7877d4a 100644
--- a/src/slang-nodes/EventParameters.ts
+++ b/src/slang-nodes/EventParameters.ts
@@ -25,7 +25,7 @@ export class EventParameters extends SlangNode {
     );
   }
 
-  print(path: AstPath<EventParameters>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<EventParameters>): Doc {
     return this.items.length > 0
       ? printSeparatedList(path.map(print, 'items'))
       : '';
diff --git a/src/slang-nodes/EventParametersDeclaration.ts b/src/slang-nodes/EventParametersDeclaration.ts
index dd8210644..64d56d942 100644
--- a/src/slang-nodes/EventParametersDeclaration.ts
+++ b/src/slang-nodes/EventParametersDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { EventParameters } from './EventParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class EventParametersDeclaration extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<EventParametersDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'parameters'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('parameters'), ')'];
   }
 }
diff --git a/src/slang-nodes/ExperimentalPragma.ts b/src/slang-nodes/ExperimentalPragma.ts
index b4ad8b39a..86a2f2964 100644
--- a/src/slang-nodes/ExperimentalPragma.ts
+++ b/src/slang-nodes/ExperimentalPragma.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { ExperimentalFeature } from './ExperimentalFeature.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class ExperimentalPragma extends SlangNode {
     this.updateMetadata(this.feature);
   }
 
-  print(path: AstPath<ExperimentalPragma>, print: PrintFunction): Doc {
-    return ['experimental ', path.call(print, 'feature')];
+  print(print: PrintFunction): Doc {
+    return ['experimental ', print('feature')];
   }
 }
diff --git a/src/slang-nodes/ExponentiationExpression.ts b/src/slang-nodes/ExponentiationExpression.ts
index 7c7ca4750..64f09cf7e 100644
--- a/src/slang-nodes/ExponentiationExpression.ts
+++ b/src/slang-nodes/ExponentiationExpression.ts
@@ -68,8 +68,8 @@ export class ExponentiationExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<ExponentiationExpression>,
     print: PrintFunction,
+    path: AstPath<ExponentiationExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printExponentiationExpression(this, path, print, options);
diff --git a/src/slang-nodes/ExpressionStatement.ts b/src/slang-nodes/ExpressionStatement.ts
index a15d6ac78..5843953ca 100644
--- a/src/slang-nodes/ExpressionStatement.ts
+++ b/src/slang-nodes/ExpressionStatement.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class ExpressionStatement extends SlangNode {
     this.updateMetadata(this.expression);
   }
 
-  print(path: AstPath<ExpressionStatement>, print: PrintFunction): Doc {
-    return [path.call(print, 'expression'), ';'];
+  print(print: PrintFunction): Doc {
+    return [print('expression'), ';'];
   }
 }
diff --git a/src/slang-nodes/FallbackFunctionAttributes.ts b/src/slang-nodes/FallbackFunctionAttributes.ts
index 97455679a..5687bc3d4 100644
--- a/src/slang-nodes/FallbackFunctionAttributes.ts
+++ b/src/slang-nodes/FallbackFunctionAttributes.ts
@@ -31,7 +31,7 @@ export class FallbackFunctionAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<FallbackFunctionAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<FallbackFunctionAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts
index d04aca172..4b328474b 100644
--- a/src/slang-nodes/FallbackFunctionDefinition.ts
+++ b/src/slang-nodes/FallbackFunctionDefinition.ts
@@ -8,7 +8,7 @@ import { ReturnsDeclaration } from './ReturnsDeclaration.js';
 import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -59,7 +59,7 @@ export class FallbackFunctionDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<FallbackFunctionDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody('fallback', this, path, print);
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody('fallback', this, print);
   }
 }
diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts
index 35d07b0e4..36bbf9994 100644
--- a/src/slang-nodes/ForStatement.ts
+++ b/src/slang-nodes/ForStatement.ts
@@ -10,7 +10,7 @@ import { Expression } from './Expression.js';
 import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -55,10 +55,10 @@ export class ForStatement extends SlangNode {
     );
   }
 
-  print(path: AstPath<ForStatement>, print: PrintFunction): Doc {
-    const initialization = path.call(print, 'initialization');
-    const condition = path.call(print, 'condition');
-    const iterator = path.call(print, 'iterator');
+  print(print: PrintFunction): Doc {
+    const initialization = print('initialization');
+    const condition = print('condition');
+    const iterator = print('iterator');
 
     return [
       'for (',
@@ -70,7 +70,7 @@ export class ForStatement extends SlangNode {
       }),
       ')',
       printIndentedGroupOrSpacedDocument(
-        path.call(print, 'body'),
+        print('body'),
         this.body.kind !== NonterminalKind.Block
       )
     ];
diff --git a/src/slang-nodes/FunctionAttributes.ts b/src/slang-nodes/FunctionAttributes.ts
index a8c3cc50e..f084b9360 100644
--- a/src/slang-nodes/FunctionAttributes.ts
+++ b/src/slang-nodes/FunctionAttributes.ts
@@ -31,7 +31,7 @@ export class FunctionAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<FunctionAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<FunctionAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/FunctionCallExpression.ts b/src/slang-nodes/FunctionCallExpression.ts
index ffdf91f03..bb61022ae 100644
--- a/src/slang-nodes/FunctionCallExpression.ts
+++ b/src/slang-nodes/FunctionCallExpression.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,10 +34,10 @@ export class FunctionCallExpression extends SlangNode {
     this.updateMetadata(this.operand, this.arguments);
   }
 
-  print(path: AstPath<FunctionCallExpression>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return printPossibleMemberAccessChainItem(
-      path.call(print, 'operand'),
-      path.call(print, 'arguments')
+      print('operand'),
+      print('arguments')
     );
   }
 }
diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts
index 42fd54902..543651fec 100644
--- a/src/slang-nodes/FunctionDefinition.ts
+++ b/src/slang-nodes/FunctionDefinition.ts
@@ -10,7 +10,7 @@ import { ReturnsDeclaration } from './ReturnsDeclaration.js';
 import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -75,12 +75,7 @@ export class FunctionDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<FunctionDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody(
-      ['function ', path.call(print, 'name')],
-      this,
-      path,
-      print
-    );
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody(['function ', print('name')], this, print);
   }
 }
diff --git a/src/slang-nodes/FunctionType.ts b/src/slang-nodes/FunctionType.ts
index 83138876f..5b277b927 100644
--- a/src/slang-nodes/FunctionType.ts
+++ b/src/slang-nodes/FunctionType.ts
@@ -6,7 +6,7 @@ import { FunctionTypeAttributes } from './FunctionTypeAttributes.js';
 import { ReturnsDeclaration } from './ReturnsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -39,7 +39,7 @@ export class FunctionType extends SlangNode {
     this.updateMetadata(this.parameters, this.attributes, this.returns);
   }
 
-  print(path: AstPath<FunctionType>, print: PrintFunction): Doc {
-    return printFunction('function', this, path, print);
+  print(print: PrintFunction): Doc {
+    return printFunction('function', this, print);
   }
 }
diff --git a/src/slang-nodes/FunctionTypeAttributes.ts b/src/slang-nodes/FunctionTypeAttributes.ts
index 702b7220e..d5aca46dd 100644
--- a/src/slang-nodes/FunctionTypeAttributes.ts
+++ b/src/slang-nodes/FunctionTypeAttributes.ts
@@ -26,7 +26,7 @@ export class FunctionTypeAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<FunctionTypeAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<FunctionTypeAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/HexNumberExpression.ts b/src/slang-nodes/HexNumberExpression.ts
index c55869834..a55f3dc95 100644
--- a/src/slang-nodes/HexNumberExpression.ts
+++ b/src/slang-nodes/HexNumberExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { NumberUnit } from './NumberUnit.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class HexNumberExpression extends SlangNode {
@@ -25,7 +25,7 @@ export class HexNumberExpression extends SlangNode {
     this.updateMetadata(this.unit);
   }
 
-  print(path: AstPath<HexNumberExpression>, print: PrintFunction): Doc {
-    return joinExisting(' ', [this.literal, path.call(print, 'unit')]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [this.literal, print('unit')]);
   }
 }
diff --git a/src/slang-nodes/HexStringLiterals.ts b/src/slang-nodes/HexStringLiterals.ts
index 6f8775181..aba2f2a75 100644
--- a/src/slang-nodes/HexStringLiterals.ts
+++ b/src/slang-nodes/HexStringLiterals.ts
@@ -27,7 +27,7 @@ export class HexStringLiterals extends SlangNode {
     );
   }
 
-  print(path: AstPath<HexStringLiterals>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<HexStringLiterals>): Doc {
     return join(hardline, path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/IdentifierPath.ts b/src/slang-nodes/IdentifierPath.ts
index 453159fa9..c1f5b68dd 100644
--- a/src/slang-nodes/IdentifierPath.ts
+++ b/src/slang-nodes/IdentifierPath.ts
@@ -20,7 +20,7 @@ export class IdentifierPath extends SlangNode {
     this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
-  print(path: AstPath<IdentifierPath>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<IdentifierPath>): Doc {
     return join('.', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/IfStatement.ts b/src/slang-nodes/IfStatement.ts
index ba7ced3d9..e4f0a4cd6 100644
--- a/src/slang-nodes/IfStatement.ts
+++ b/src/slang-nodes/IfStatement.ts
@@ -10,7 +10,7 @@ import { Statement } from './Statement.js';
 import { ElseBranch } from './ElseBranch.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -43,14 +43,14 @@ export class IfStatement extends SlangNode {
     this.updateMetadata(this.condition, this.body, this.elseBranch);
   }
 
-  print(path: AstPath<IfStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     const { kind: bodyKind, comments: bodyComments } = this.body;
     return [
       'if (',
-      printSeparatedItem(path.call(print, 'condition')),
+      printSeparatedItem(print('condition')),
       ')',
       printIndentedGroupOrSpacedDocument(
-        path.call(print, 'body'),
+        print('body'),
         bodyKind !== NonterminalKind.Block,
         // `if` within `if`
         { shouldBreak: bodyKind === NonterminalKind.IfStatement }
@@ -64,7 +64,7 @@ export class IfStatement extends SlangNode {
             ) // or if body has trailing single line comments or a block comment on a new line
               ? hardline
               : ' ',
-            path.call(print, 'elseBranch')
+            print('elseBranch')
           ]
         : ''
     ];
diff --git a/src/slang-nodes/ImportAlias.ts b/src/slang-nodes/ImportAlias.ts
index 39dd337d8..bccc2fb52 100644
--- a/src/slang-nodes/ImportAlias.ts
+++ b/src/slang-nodes/ImportAlias.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class ImportAlias extends SlangNode {
@@ -17,7 +17,7 @@ export class ImportAlias extends SlangNode {
     this.identifier = new TerminalNode(ast.identifier, collected);
   }
 
-  print(path: AstPath<ImportAlias>, print: PrintFunction): Doc {
-    return [' as ', path.call(print, 'identifier')];
+  print(print: PrintFunction): Doc {
+    return [' as ', print('identifier')];
   }
 }
diff --git a/src/slang-nodes/ImportDeconstruction.ts b/src/slang-nodes/ImportDeconstruction.ts
index 6b1790d29..a97eb88f7 100644
--- a/src/slang-nodes/ImportDeconstruction.ts
+++ b/src/slang-nodes/ImportDeconstruction.ts
@@ -4,7 +4,7 @@ import { ImportDeconstructionSymbols } from './ImportDeconstructionSymbols.js';
 import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -28,12 +28,7 @@ export class ImportDeconstruction extends SlangNode {
     this.updateMetadata(this.symbols, this.path);
   }
 
-  print(path: AstPath<ImportDeconstruction>, print: PrintFunction): Doc {
-    return [
-      '{',
-      path.call(print, 'symbols'),
-      '} from ',
-      path.call(print, 'path')
-    ];
+  print(print: PrintFunction): Doc {
+    return ['{', print('symbols'), '} from ', print('path')];
   }
 }
diff --git a/src/slang-nodes/ImportDeconstructionSymbol.ts b/src/slang-nodes/ImportDeconstructionSymbol.ts
index 8c15c05f6..893d8442e 100644
--- a/src/slang-nodes/ImportDeconstructionSymbol.ts
+++ b/src/slang-nodes/ImportDeconstructionSymbol.ts
@@ -4,7 +4,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { ImportAlias } from './ImportAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class ImportDeconstructionSymbol extends SlangNode {
@@ -28,7 +28,7 @@ export class ImportDeconstructionSymbol extends SlangNode {
     this.updateMetadata(this.alias);
   }
 
-  print(path: AstPath<ImportDeconstructionSymbol>, print: PrintFunction): Doc {
-    return [path.call(print, 'name'), path.call(print, 'alias')];
+  print(print: PrintFunction): Doc {
+    return [print('name'), print('alias')];
   }
 }
diff --git a/src/slang-nodes/ImportDeconstructionSymbols.ts b/src/slang-nodes/ImportDeconstructionSymbols.ts
index d4275d308..6bfed660c 100644
--- a/src/slang-nodes/ImportDeconstructionSymbols.ts
+++ b/src/slang-nodes/ImportDeconstructionSymbols.ts
@@ -29,8 +29,8 @@ export class ImportDeconstructionSymbols extends SlangNode {
   }
 
   print(
-    path: AstPath<ImportDeconstructionSymbols>,
     print: PrintFunction,
+    path: AstPath<ImportDeconstructionSymbols>,
     { compiler, bracketSpacing }: ParserOptions<PrintableNode>
   ): Doc {
     const items = path.map(print, 'items');
diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts
index 58b120eb5..f1ccfb98c 100644
--- a/src/slang-nodes/ImportDirective.ts
+++ b/src/slang-nodes/ImportDirective.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { ImportClause } from './ImportClause.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class ImportDirective extends SlangNode {
     this.updateMetadata(this.clause);
   }
 
-  print(path: AstPath<ImportDirective>, print: PrintFunction): Doc {
-    return ['import ', path.call(print, 'clause'), ';'];
+  print(print: PrintFunction): Doc {
+    return ['import ', print('clause'), ';'];
   }
 }
diff --git a/src/slang-nodes/IndexAccessEnd.ts b/src/slang-nodes/IndexAccessEnd.ts
index 1d774b092..2b7b63e16 100644
--- a/src/slang-nodes/IndexAccessEnd.ts
+++ b/src/slang-nodes/IndexAccessEnd.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class IndexAccessEnd extends SlangNode {
     this.updateMetadata(this.end);
   }
 
-  print(path: AstPath<IndexAccessEnd>, print: PrintFunction): Doc {
-    return [':', path.call(print, 'end')];
+  print(print: PrintFunction): Doc {
+    return [':', print('end')];
   }
 }
diff --git a/src/slang-nodes/IndexAccessExpression.ts b/src/slang-nodes/IndexAccessExpression.ts
index 0d8458116..25dbf8575 100644
--- a/src/slang-nodes/IndexAccessExpression.ts
+++ b/src/slang-nodes/IndexAccessExpression.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 import { IndexAccessEnd } from './IndexAccessEnd.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -42,10 +42,10 @@ export class IndexAccessExpression extends SlangNode {
     this.updateMetadata(this.operand, this.start, this.end);
   }
 
-  print(path: AstPath<IndexAccessExpression>, print: PrintFunction): Doc {
-    return printPossibleMemberAccessChainItem(path.call(print, 'operand'), [
+  print(print: PrintFunction): Doc {
+    return printPossibleMemberAccessChainItem(print('operand'), [
       '[',
-      printSeparatedItem([path.call(print, 'start'), path.call(print, 'end')]),
+      printSeparatedItem([print('start'), print('end')]),
       ']'
     ]);
   }
diff --git a/src/slang-nodes/InequalityExpression.ts b/src/slang-nodes/InequalityExpression.ts
index 027a26ae1..80bcbf013 100644
--- a/src/slang-nodes/InequalityExpression.ts
+++ b/src/slang-nodes/InequalityExpression.ts
@@ -46,8 +46,8 @@ export class InequalityExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<InequalityExpression>,
     print: PrintFunction,
+    path: AstPath<InequalityExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printComparisonExpression(this, path, print, options);
diff --git a/src/slang-nodes/InheritanceSpecifier.ts b/src/slang-nodes/InheritanceSpecifier.ts
index 3288246c6..efcad795f 100644
--- a/src/slang-nodes/InheritanceSpecifier.ts
+++ b/src/slang-nodes/InheritanceSpecifier.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { InheritanceTypes } from './InheritanceTypes.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class InheritanceSpecifier extends SlangNode {
     this.updateMetadata(this.types);
   }
 
-  print(path: AstPath<InheritanceSpecifier>, print: PrintFunction): Doc {
-    return ['is', path.call(print, 'types')];
+  print(print: PrintFunction): Doc {
+    return ['is', print('types')];
   }
 }
diff --git a/src/slang-nodes/InheritanceType.ts b/src/slang-nodes/InheritanceType.ts
index 0415d37e0..a2cc81e04 100644
--- a/src/slang-nodes/InheritanceType.ts
+++ b/src/slang-nodes/InheritanceType.ts
@@ -5,7 +5,7 @@ import { IdentifierPath } from './IdentifierPath.js';
 import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -33,7 +33,7 @@ export class InheritanceType extends SlangNode {
     this.updateMetadata(this.typeName, this.arguments);
   }
 
-  print(path: AstPath<InheritanceType>, print: PrintFunction): Doc {
-    return [path.call(print, 'typeName'), path.call(print, 'arguments')];
+  print(print: PrintFunction): Doc {
+    return [print('typeName'), print('arguments')];
   }
 }
diff --git a/src/slang-nodes/InheritanceTypes.ts b/src/slang-nodes/InheritanceTypes.ts
index 3d2c840da..011827403 100644
--- a/src/slang-nodes/InheritanceTypes.ts
+++ b/src/slang-nodes/InheritanceTypes.ts
@@ -28,7 +28,7 @@ export class InheritanceTypes extends SlangNode {
     );
   }
 
-  print(path: AstPath<InheritanceTypes>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<InheritanceTypes>): Doc {
     return printSeparatedList(path.map(print, 'items'), {
       firstSeparator: line
     });
diff --git a/src/slang-nodes/InterfaceDefinition.ts b/src/slang-nodes/InterfaceDefinition.ts
index f81b057ea..9840a900d 100644
--- a/src/slang-nodes/InterfaceDefinition.ts
+++ b/src/slang-nodes/InterfaceDefinition.ts
@@ -6,7 +6,7 @@ import { InheritanceSpecifier } from './InheritanceSpecifier.js';
 import { InterfaceMembers } from './InterfaceMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -41,15 +41,15 @@ export class InterfaceDefinition extends SlangNode {
     this.updateMetadata(this.inheritance, this.members);
   }
 
-  print(path: AstPath<InterfaceDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       group([
         'interface ',
-        path.call(print, 'name'),
-        this.inheritance ? [' ', path.call(print, 'inheritance')] : line,
+        print('name'),
+        this.inheritance ? [' ', print('inheritance')] : line,
         '{'
       ]),
-      path.call(print, 'members'),
+      print('members'),
       '}'
     ];
   }
diff --git a/src/slang-nodes/InterfaceMembers.ts b/src/slang-nodes/InterfaceMembers.ts
index 23773f164..92fb0833c 100644
--- a/src/slang-nodes/InterfaceMembers.ts
+++ b/src/slang-nodes/InterfaceMembers.ts
@@ -31,8 +31,8 @@ export class InterfaceMembers extends SlangNode {
   }
 
   print(
-    path: AstPath<InterfaceMembers>,
     print: PrintFunction,
+    path: AstPath<InterfaceMembers>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
diff --git a/src/slang-nodes/LibraryDefinition.ts b/src/slang-nodes/LibraryDefinition.ts
index 78621fac9..06d96c2a8 100644
--- a/src/slang-nodes/LibraryDefinition.ts
+++ b/src/slang-nodes/LibraryDefinition.ts
@@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { LibraryMembers } from './LibraryMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -44,10 +44,10 @@ export class LibraryDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<LibraryDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
-      group(['library ', path.call(print, 'name'), line, '{']),
-      path.call(print, 'members'),
+      group(['library ', print('name'), line, '{']),
+      print('members'),
       '}'
     ];
   }
diff --git a/src/slang-nodes/LibraryMembers.ts b/src/slang-nodes/LibraryMembers.ts
index fd2a32e6b..fb2f012d7 100644
--- a/src/slang-nodes/LibraryMembers.ts
+++ b/src/slang-nodes/LibraryMembers.ts
@@ -31,8 +31,8 @@ export class LibraryMembers extends SlangNode {
   }
 
   print(
-    path: AstPath<LibraryMembers>,
     print: PrintFunction,
+    path: AstPath<LibraryMembers>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
diff --git a/src/slang-nodes/MappingKey.ts b/src/slang-nodes/MappingKey.ts
index ab2ebb515..dedf547b5 100644
--- a/src/slang-nodes/MappingKey.ts
+++ b/src/slang-nodes/MappingKey.ts
@@ -6,7 +6,7 @@ import { MappingKeyType } from './MappingKeyType.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class MappingKey extends SlangNode {
@@ -27,10 +27,7 @@ export class MappingKey extends SlangNode {
     this.updateMetadata(this.keyType);
   }
 
-  print(path: AstPath<MappingKey>, print: PrintFunction): Doc {
-    return joinExisting(' ', [
-      path.call(print, 'keyType'),
-      path.call(print, 'name')
-    ]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [print('keyType'), print('name')]);
   }
 }
diff --git a/src/slang-nodes/MappingType.ts b/src/slang-nodes/MappingType.ts
index 7ea466790..819825975 100644
--- a/src/slang-nodes/MappingType.ts
+++ b/src/slang-nodes/MappingType.ts
@@ -4,7 +4,7 @@ import { MappingKey } from './MappingKey.js';
 import { MappingValue } from './MappingValue.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -28,13 +28,7 @@ export class MappingType extends SlangNode {
     this.updateMetadata(this.keyType, this.valueType);
   }
 
-  print(path: AstPath<MappingType>, print: PrintFunction): Doc {
-    return [
-      'mapping(',
-      path.call(print, 'keyType'),
-      ' => ',
-      path.call(print, 'valueType'),
-      ')'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['mapping(', print('keyType'), ' => ', print('valueType'), ')'];
   }
 }
diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts
index de01274ac..0df330500 100644
--- a/src/slang-nodes/MappingValue.ts
+++ b/src/slang-nodes/MappingValue.ts
@@ -6,7 +6,7 @@ import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,10 +34,7 @@ export class MappingValue extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<MappingValue>, print: PrintFunction): Doc {
-    return joinExisting(' ', [
-      path.call(print, 'typeName'),
-      path.call(print, 'name')
-    ]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [print('typeName'), print('name')]);
   }
 }
diff --git a/src/slang-nodes/MemberAccessExpression.ts b/src/slang-nodes/MemberAccessExpression.ts
index 81278f733..921283b9a 100644
--- a/src/slang-nodes/MemberAccessExpression.ts
+++ b/src/slang-nodes/MemberAccessExpression.ts
@@ -130,8 +130,8 @@ export class MemberAccessExpression extends SlangNode {
     this.updateMetadata(this.operand);
   }
 
-  print(path: AstPath<MemberAccessExpression>, print: PrintFunction): Doc {
-    let operandDoc = path.call(print, 'operand');
+  print(print: PrintFunction, path: AstPath<MemberAccessExpression>): Doc {
+    let operandDoc = print('operand');
     if (Array.isArray(operandDoc)) {
       operandDoc = operandDoc.flat();
     }
@@ -139,7 +139,7 @@ export class MemberAccessExpression extends SlangNode {
     const document = [
       operandDoc,
       label(separatorLabel, [softline, '.']),
-      path.call(print, 'member')
+      print('member')
     ].flat();
 
     return isEndOfChain(this, path) ? processChain(document) : document;
diff --git a/src/slang-nodes/ModifierAttributes.ts b/src/slang-nodes/ModifierAttributes.ts
index e440e75c2..db22a0ed2 100644
--- a/src/slang-nodes/ModifierAttributes.ts
+++ b/src/slang-nodes/ModifierAttributes.ts
@@ -26,7 +26,7 @@ export class ModifierAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<ModifierAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<ModifierAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts
index 13105b73e..e067c0598 100644
--- a/src/slang-nodes/ModifierDefinition.ts
+++ b/src/slang-nodes/ModifierDefinition.ts
@@ -9,7 +9,7 @@ import { ModifierAttributes } from './ModifierAttributes.js';
 import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type {
   AstLocation,
   CollectedMetadata,
@@ -62,13 +62,13 @@ export class ModifierDefinition extends SlangNode {
         {
           kind: NonterminalKind.ParametersDeclaration,
           loc: { ...parametersLoc },
-          comments: [],
+          comments: undefined,
           parameters: Object.assign(
             Object.create(Parameters.prototype) as Parameters,
             {
               kind: NonterminalKind.Parameters,
               loc: { ...parametersLoc },
-              comments: [],
+              comments: undefined,
               items: []
             }
           )
@@ -77,12 +77,7 @@ export class ModifierDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<ModifierDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody(
-      ['modifier ', path.call(print, 'name')],
-      this,
-      path,
-      print
-    );
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody(['modifier ', print('name')], this, print);
   }
 }
diff --git a/src/slang-nodes/ModifierInvocation.ts b/src/slang-nodes/ModifierInvocation.ts
index 4c331859d..a144faa2d 100644
--- a/src/slang-nodes/ModifierInvocation.ts
+++ b/src/slang-nodes/ModifierInvocation.ts
@@ -5,7 +5,7 @@ import { IdentifierPath } from './IdentifierPath.js';
 import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -38,11 +38,11 @@ export class ModifierInvocation extends SlangNode {
       this.arguments?.kind === NonterminalKind.PositionalArgumentsDeclaration &&
       this.arguments.isEmpty
     ) {
-      delete this.arguments;
+      this.arguments = undefined;
     }
   }
 
-  print(path: AstPath<ModifierInvocation>, print: PrintFunction): Doc {
-    return [path.call(print, 'name'), path.call(print, 'arguments')];
+  print(print: PrintFunction): Doc {
+    return [print('name'), print('arguments')];
   }
 }
diff --git a/src/slang-nodes/MultiplicativeExpression.ts b/src/slang-nodes/MultiplicativeExpression.ts
index 81c85877f..5a1a7415f 100644
--- a/src/slang-nodes/MultiplicativeExpression.ts
+++ b/src/slang-nodes/MultiplicativeExpression.ts
@@ -67,8 +67,8 @@ export class MultiplicativeExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<MultiplicativeExpression>,
     print: PrintFunction,
+    path: AstPath<MultiplicativeExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printMultiplicativeExpression(this, path, print, options);
diff --git a/src/slang-nodes/NamedArgument.ts b/src/slang-nodes/NamedArgument.ts
index 8c51561ba..84c73f178 100644
--- a/src/slang-nodes/NamedArgument.ts
+++ b/src/slang-nodes/NamedArgument.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -29,7 +29,7 @@ export class NamedArgument extends SlangNode {
     this.updateMetadata(this.value);
   }
 
-  print(path: AstPath<NamedArgument>, print: PrintFunction): Doc {
-    return [path.call(print, 'name'), ': ', path.call(print, 'value')];
+  print(print: PrintFunction): Doc {
+    return [print('name'), ': ', print('value')];
   }
 }
diff --git a/src/slang-nodes/NamedArgumentGroup.ts b/src/slang-nodes/NamedArgumentGroup.ts
index 8f8d5468d..f12878d9b 100644
--- a/src/slang-nodes/NamedArgumentGroup.ts
+++ b/src/slang-nodes/NamedArgumentGroup.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { NamedArguments } from './NamedArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class NamedArgumentGroup extends SlangNode {
     this.updateMetadata(this.arguments);
   }
 
-  print(path: AstPath<NamedArgumentGroup>, print: PrintFunction): Doc {
-    return ['{', path.call(print, 'arguments'), '}'];
+  print(print: PrintFunction): Doc {
+    return ['{', print('arguments'), '}'];
   }
 }
diff --git a/src/slang-nodes/NamedArguments.ts b/src/slang-nodes/NamedArguments.ts
index 93eacdf75..2b4fb3c4c 100644
--- a/src/slang-nodes/NamedArguments.ts
+++ b/src/slang-nodes/NamedArguments.ts
@@ -29,8 +29,8 @@ export class NamedArguments extends SlangNode {
   }
 
   print(
-    path: AstPath<NamedArguments>,
     print: PrintFunction,
+    path: AstPath<NamedArguments>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printSeparatedList(path.map(print, 'items'), {
diff --git a/src/slang-nodes/NamedArgumentsDeclaration.ts b/src/slang-nodes/NamedArgumentsDeclaration.ts
index 0aa8d0627..6e900e5d3 100644
--- a/src/slang-nodes/NamedArgumentsDeclaration.ts
+++ b/src/slang-nodes/NamedArgumentsDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { NamedArgumentGroup } from './NamedArgumentGroup.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -30,7 +30,7 @@ export class NamedArgumentsDeclaration extends SlangNode {
     this.updateMetadata(this.arguments);
   }
 
-  print(path: AstPath<NamedArgumentsDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'arguments'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('arguments'), ')'];
   }
 }
diff --git a/src/slang-nodes/NamedImport.ts b/src/slang-nodes/NamedImport.ts
index be5faddaa..5238681f9 100644
--- a/src/slang-nodes/NamedImport.ts
+++ b/src/slang-nodes/NamedImport.ts
@@ -4,7 +4,7 @@ import { ImportAlias } from './ImportAlias.js';
 import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -28,7 +28,7 @@ export class NamedImport extends SlangNode {
     this.updateMetadata(this.alias, this.path);
   }
 
-  print(path: AstPath<NamedImport>, print: PrintFunction): Doc {
-    return ['*', path.call(print, 'alias'), ' from ', path.call(print, 'path')];
+  print(print: PrintFunction): Doc {
+    return ['*', print('alias'), ' from ', print('path')];
   }
 }
diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts
index 93feddac8..0331037a8 100644
--- a/src/slang-nodes/NewExpression.ts
+++ b/src/slang-nodes/NewExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class NewExpression extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<NewExpression>, print: PrintFunction): Doc {
-    return ['new ', path.call(print, 'typeName')];
+  print(print: PrintFunction): Doc {
+    return ['new ', print('typeName')];
   }
 }
diff --git a/src/slang-nodes/OrExpression.ts b/src/slang-nodes/OrExpression.ts
index a9bb4169d..f67a80f42 100644
--- a/src/slang-nodes/OrExpression.ts
+++ b/src/slang-nodes/OrExpression.ts
@@ -43,8 +43,8 @@ export class OrExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<OrExpression>,
     print: PrintFunction,
+    path: AstPath<OrExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printLogicalOperation(this, path, print, options);
diff --git a/src/slang-nodes/OverridePaths.ts b/src/slang-nodes/OverridePaths.ts
index 5496b0e10..01c5d93d4 100644
--- a/src/slang-nodes/OverridePaths.ts
+++ b/src/slang-nodes/OverridePaths.ts
@@ -18,7 +18,7 @@ export class OverridePaths extends SlangNode {
     this.items = ast.items.map((item) => new IdentifierPath(item, collected));
   }
 
-  print(path: AstPath<OverridePaths>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<OverridePaths>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/OverridePathsDeclaration.ts b/src/slang-nodes/OverridePathsDeclaration.ts
index 8fdefa2bd..ce321c8be 100644
--- a/src/slang-nodes/OverridePathsDeclaration.ts
+++ b/src/slang-nodes/OverridePathsDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { OverridePaths } from './OverridePaths.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class OverridePathsDeclaration extends SlangNode {
@@ -19,7 +19,7 @@ export class OverridePathsDeclaration extends SlangNode {
     this.updateMetadata(this.paths);
   }
 
-  print(path: AstPath<OverridePathsDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'paths'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('paths'), ')'];
   }
 }
diff --git a/src/slang-nodes/OverrideSpecifier.ts b/src/slang-nodes/OverrideSpecifier.ts
index 3b354575e..1980244ad 100644
--- a/src/slang-nodes/OverrideSpecifier.ts
+++ b/src/slang-nodes/OverrideSpecifier.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { OverridePathsDeclaration } from './OverridePathsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class OverrideSpecifier extends SlangNode {
@@ -21,7 +21,7 @@ export class OverrideSpecifier extends SlangNode {
     this.updateMetadata(this.overridden);
   }
 
-  print(path: AstPath<OverrideSpecifier>, print: PrintFunction): Doc {
-    return ['override', path.call(print, 'overridden')];
+  print(print: PrintFunction): Doc {
+    return ['override', print('overridden')];
   }
 }
diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts
index f40c61910..fac9c2ef6 100644
--- a/src/slang-nodes/Parameter.ts
+++ b/src/slang-nodes/Parameter.ts
@@ -8,7 +8,7 @@ import { StorageLocation } from './StorageLocation.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -46,12 +46,12 @@ export class Parameter extends SlangNode {
     this.updateMetadata(this.typeName, this.storageLocation);
   }
 
-  print(path: AstPath<Parameter>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return group(
       joinExisting(' ', [
-        path.call(print, 'typeName'),
-        path.call(print, 'storageLocation'),
-        path.call(print, 'name')
+        print('typeName'),
+        print('storageLocation'),
+        print('name')
       ])
     );
   }
diff --git a/src/slang-nodes/Parameters.ts b/src/slang-nodes/Parameters.ts
index 3c6b0d91e..43ee709f8 100644
--- a/src/slang-nodes/Parameters.ts
+++ b/src/slang-nodes/Parameters.ts
@@ -28,8 +28,8 @@ export class Parameters extends SlangNode {
   }
 
   print(
-    path: AstPath<Parameters>,
     print: PrintFunction,
+    path: AstPath<Parameters>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     if (this.items.length > 0) {
diff --git a/src/slang-nodes/ParametersDeclaration.ts b/src/slang-nodes/ParametersDeclaration.ts
index 61bf6f142..9d139eb63 100644
--- a/src/slang-nodes/ParametersDeclaration.ts
+++ b/src/slang-nodes/ParametersDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { Parameters } from './Parameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class ParametersDeclaration extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<ParametersDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'parameters'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('parameters'), ')'];
   }
 }
diff --git a/src/slang-nodes/PathImport.ts b/src/slang-nodes/PathImport.ts
index 4038189f5..e46e18338 100644
--- a/src/slang-nodes/PathImport.ts
+++ b/src/slang-nodes/PathImport.ts
@@ -4,7 +4,7 @@ import { StringLiteral } from './StringLiteral.js';
 import { ImportAlias } from './ImportAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -30,7 +30,7 @@ export class PathImport extends SlangNode {
     this.updateMetadata(this.path, this.alias);
   }
 
-  print(path: AstPath<PathImport>, print: PrintFunction): Doc {
-    return [path.call(print, 'path'), path.call(print, 'alias')];
+  print(print: PrintFunction): Doc {
+    return [print('path'), print('alias')];
   }
 }
diff --git a/src/slang-nodes/PositionalArguments.ts b/src/slang-nodes/PositionalArguments.ts
index 3ddeea205..ed0b538ae 100644
--- a/src/slang-nodes/PositionalArguments.ts
+++ b/src/slang-nodes/PositionalArguments.ts
@@ -29,8 +29,8 @@ export class PositionalArguments extends SlangNode {
   }
 
   print(
-    path: AstPath<PositionalArguments>,
     print: PrintFunction,
+    path: AstPath<PositionalArguments>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     if (this.items.length > 0) {
diff --git a/src/slang-nodes/PositionalArgumentsDeclaration.ts b/src/slang-nodes/PositionalArgumentsDeclaration.ts
index e44bce805..88ddec4fe 100644
--- a/src/slang-nodes/PositionalArgumentsDeclaration.ts
+++ b/src/slang-nodes/PositionalArgumentsDeclaration.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { PositionalArguments } from './PositionalArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -35,10 +35,7 @@ export class PositionalArgumentsDeclaration extends SlangNode {
       !ast.cst.children().some(({ node }) => isBlockComment(node)); // no block comments
   }
 
-  print(
-    path: AstPath<PositionalArgumentsDeclaration>,
-    print: PrintFunction
-  ): Doc {
-    return ['(', path.call(print, 'arguments'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('arguments'), ')'];
   }
 }
diff --git a/src/slang-nodes/PostfixExpression.ts b/src/slang-nodes/PostfixExpression.ts
index 560082b10..863c83218 100644
--- a/src/slang-nodes/PostfixExpression.ts
+++ b/src/slang-nodes/PostfixExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -30,7 +30,7 @@ export class PostfixExpression extends SlangNode {
     this.updateMetadata(this.operand);
   }
 
-  print(path: AstPath<PostfixExpression>, print: PrintFunction): Doc {
-    return [path.call(print, 'operand'), this.operator];
+  print(print: PrintFunction): Doc {
+    return [print('operand'), this.operator];
   }
 }
diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts
index d63ba7c2e..fd6226668 100644
--- a/src/slang-nodes/PragmaDirective.ts
+++ b/src/slang-nodes/PragmaDirective.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Pragma } from './Pragma.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -25,7 +25,7 @@ export class PragmaDirective extends SlangNode {
     this.updateMetadata(this.pragma);
   }
 
-  print(path: AstPath<PragmaDirective>, print: PrintFunction): Doc {
-    return ['pragma ', path.call(print, 'pragma'), ';'];
+  print(print: PrintFunction): Doc {
+    return ['pragma ', print('pragma'), ';'];
   }
 }
diff --git a/src/slang-nodes/PrefixExpression.ts b/src/slang-nodes/PrefixExpression.ts
index 142bec143..3910d2f61 100644
--- a/src/slang-nodes/PrefixExpression.ts
+++ b/src/slang-nodes/PrefixExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,7 +34,7 @@ export class PrefixExpression extends SlangNode {
     }
   }
 
-  print(path: AstPath<PrefixExpression>, print: PrintFunction): Doc {
-    return [this.operator, path.call(print, 'operand')];
+  print(print: PrintFunction): Doc {
+    return [this.operator, print('operand')];
   }
 }
diff --git a/src/slang-nodes/ReceiveFunctionAttributes.ts b/src/slang-nodes/ReceiveFunctionAttributes.ts
index 78804d3d0..da82ef171 100644
--- a/src/slang-nodes/ReceiveFunctionAttributes.ts
+++ b/src/slang-nodes/ReceiveFunctionAttributes.ts
@@ -31,7 +31,7 @@ export class ReceiveFunctionAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<ReceiveFunctionAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<ReceiveFunctionAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts
index 44ffa8177..32137b17e 100644
--- a/src/slang-nodes/ReceiveFunctionDefinition.ts
+++ b/src/slang-nodes/ReceiveFunctionDefinition.ts
@@ -7,7 +7,7 @@ import { ReceiveFunctionAttributes } from './ReceiveFunctionAttributes.js';
 import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -48,7 +48,7 @@ export class ReceiveFunctionDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<ReceiveFunctionDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody('receive', this, path, print);
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody('receive', this, print);
   }
 }
diff --git a/src/slang-nodes/ReturnStatement.ts b/src/slang-nodes/ReturnStatement.ts
index e59944a8e..610aa31b5 100644
--- a/src/slang-nodes/ReturnStatement.ts
+++ b/src/slang-nodes/ReturnStatement.ts
@@ -31,8 +31,8 @@ export class ReturnStatement extends SlangNode {
   }
 
   print(
-    path: AstPath<ReturnStatement>,
     print: PrintFunction,
+    _path: AstPath<ReturnStatement>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     const expressionVariantKind = this.expression?.kind;
@@ -40,7 +40,7 @@ export class ReturnStatement extends SlangNode {
       'return',
       expressionVariantKind
         ? printIndentedGroupOrSpacedDocument(
-            path.call(print, 'expression'),
+            print('expression'),
             expressionVariantKind !== NonterminalKind.TupleExpression &&
               (!options.experimentalTernaries ||
                 expressionVariantKind !== NonterminalKind.ConditionalExpression)
diff --git a/src/slang-nodes/ReturnsDeclaration.ts b/src/slang-nodes/ReturnsDeclaration.ts
index 28cfaedfd..5f37971fc 100644
--- a/src/slang-nodes/ReturnsDeclaration.ts
+++ b/src/slang-nodes/ReturnsDeclaration.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { ParametersDeclaration } from './ParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,7 +31,7 @@ export class ReturnsDeclaration extends SlangNode {
     this.updateMetadata(this.variables);
   }
 
-  print(path: AstPath<ReturnsDeclaration>, print: PrintFunction): Doc {
-    return ['returns ', group(path.call(print, 'variables'))];
+  print(print: PrintFunction): Doc {
+    return ['returns ', group(print('variables'))];
   }
 }
diff --git a/src/slang-nodes/RevertStatement.ts b/src/slang-nodes/RevertStatement.ts
index 53d400114..ac5709870 100644
--- a/src/slang-nodes/RevertStatement.ts
+++ b/src/slang-nodes/RevertStatement.ts
@@ -5,7 +5,7 @@ import { IdentifierPath } from './IdentifierPath.js';
 import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,12 +31,7 @@ export class RevertStatement extends SlangNode {
     this.updateMetadata(this.error, this.arguments);
   }
 
-  print(path: AstPath<RevertStatement>, print: PrintFunction): Doc {
-    return [
-      'revert ',
-      path.call(print, 'error'),
-      path.call(print, 'arguments'),
-      ';'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['revert ', print('error'), print('arguments'), ';'];
   }
 }
diff --git a/src/slang-nodes/ShiftExpression.ts b/src/slang-nodes/ShiftExpression.ts
index 30aa29edf..93bcb2b4e 100644
--- a/src/slang-nodes/ShiftExpression.ts
+++ b/src/slang-nodes/ShiftExpression.ts
@@ -65,8 +65,8 @@ export class ShiftExpression extends SlangNode {
   }
 
   print(
-    path: AstPath<ShiftExpression>,
     print: PrintFunction,
+    path: AstPath<ShiftExpression>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printShiftExpression(this, path, print, options);
diff --git a/src/slang-nodes/SourceUnit.ts b/src/slang-nodes/SourceUnit.ts
index 995cde43f..c4da539ab 100644
--- a/src/slang-nodes/SourceUnit.ts
+++ b/src/slang-nodes/SourceUnit.ts
@@ -28,12 +28,12 @@ export class SourceUnit extends SlangNode {
   }
 
   print(
-    path: AstPath<SourceUnit>,
     print: PrintFunction,
+    _path: AstPath<SourceUnit>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return [
-      path.call(print, 'members'),
+      print('members'),
       // Prettier's Markdown formatter already appends a new line on code
       // blocks, therefore we avoid trailing with a new line at the end of
       // a file in this case.
diff --git a/src/slang-nodes/SourceUnitMembers.ts b/src/slang-nodes/SourceUnitMembers.ts
index 8cd171910..87d6707d2 100644
--- a/src/slang-nodes/SourceUnitMembers.ts
+++ b/src/slang-nodes/SourceUnitMembers.ts
@@ -27,8 +27,8 @@ export class SourceUnitMembers extends SlangNode {
   }
 
   print(
-    path: AstPath<SourceUnitMembers>,
     print: PrintFunction,
+    path: AstPath<SourceUnitMembers>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printPreservingEmptyLines(this, path, print, options);
diff --git a/src/slang-nodes/StateVariableAttributes.ts b/src/slang-nodes/StateVariableAttributes.ts
index 02c9502ef..797a877ca 100644
--- a/src/slang-nodes/StateVariableAttributes.ts
+++ b/src/slang-nodes/StateVariableAttributes.ts
@@ -26,7 +26,7 @@ export class StateVariableAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<StateVariableAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<StateVariableAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts
index 021a4e7d7..8a85ddce6 100644
--- a/src/slang-nodes/StateVariableDefinition.ts
+++ b/src/slang-nodes/StateVariableDefinition.ts
@@ -9,7 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { StateVariableDefinitionValue } from './StateVariableDefinitionValue.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -49,15 +49,10 @@ export class StateVariableDefinition extends SlangNode {
     this.updateMetadata(this.typeName, this.attributes, this.value);
   }
 
-  print(path: AstPath<StateVariableDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return printGroupAndIndentIfBreakPair(
-      [
-        path.call(print, 'typeName'),
-        indent(path.call(print, 'attributes')),
-        ' ',
-        path.call(print, 'name')
-      ],
-      [path.call(print, 'value'), ';']
+      [print('typeName'), indent(print('attributes')), ' ', print('name')],
+      [print('value'), ';']
     );
   }
 }
diff --git a/src/slang-nodes/StateVariableDefinitionValue.ts b/src/slang-nodes/StateVariableDefinitionValue.ts
index dff87264b..aee84546b 100644
--- a/src/slang-nodes/StateVariableDefinitionValue.ts
+++ b/src/slang-nodes/StateVariableDefinitionValue.ts
@@ -5,7 +5,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -26,13 +26,7 @@ export class StateVariableDefinitionValue extends SlangNode {
     this.updateMetadata(this.value);
   }
 
-  print(
-    path: AstPath<StateVariableDefinitionValue>,
-    print: PrintFunction
-  ): Doc {
-    return [
-      ' =',
-      printAssignmentRightSide(path.call(print, 'value'), this.value)
-    ];
+  print(print: PrintFunction): Doc {
+    return [' =', printAssignmentRightSide(print('value'), this.value)];
   }
 }
diff --git a/src/slang-nodes/Statements.ts b/src/slang-nodes/Statements.ts
index d50633ae2..587902dbf 100644
--- a/src/slang-nodes/Statements.ts
+++ b/src/slang-nodes/Statements.ts
@@ -31,8 +31,8 @@ export class Statements extends SlangNode {
   }
 
   print(
-    path: AstPath<Statements>,
     print: PrintFunction,
+    path: AstPath<Statements>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
diff --git a/src/slang-nodes/StorageLayoutSpecifier.ts b/src/slang-nodes/StorageLayoutSpecifier.ts
index f1bc1debe..3df232038 100644
--- a/src/slang-nodes/StorageLayoutSpecifier.ts
+++ b/src/slang-nodes/StorageLayoutSpecifier.ts
@@ -31,10 +31,10 @@ export class StorageLayoutSpecifier extends SlangNode {
     this.updateMetadata(this.expression);
   }
 
-  print(path: AstPath<StorageLayoutSpecifier>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<StorageLayoutSpecifier>): Doc {
     return [
       'layout at',
-      printSeparatedItem(path.call(print, 'expression'), {
+      printSeparatedItem(print('expression'), {
         firstSeparator: line,
         // If this is the second ContractSpecifier we have to delegate printing
         // the line to the ContractSpecifiers node.
diff --git a/src/slang-nodes/StringLiterals.ts b/src/slang-nodes/StringLiterals.ts
index 3003cc1db..0f771306c 100644
--- a/src/slang-nodes/StringLiterals.ts
+++ b/src/slang-nodes/StringLiterals.ts
@@ -27,7 +27,7 @@ export class StringLiterals extends SlangNode {
     );
   }
 
-  print(path: AstPath<StringLiterals>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<StringLiterals>): Doc {
     return join(hardline, path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/StructDefinition.ts b/src/slang-nodes/StructDefinition.ts
index 274cd1264..829d82010 100644
--- a/src/slang-nodes/StructDefinition.ts
+++ b/src/slang-nodes/StructDefinition.ts
@@ -4,7 +4,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { StructMembers } from './StructMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -28,13 +28,7 @@ export class StructDefinition extends SlangNode {
     this.updateMetadata(this.members);
   }
 
-  print(path: AstPath<StructDefinition>, print: PrintFunction): Doc {
-    return [
-      'struct ',
-      path.call(print, 'name'),
-      ' {',
-      path.call(print, 'members'),
-      '}'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['struct ', print('name'), ' {', print('members'), '}'];
   }
 }
diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts
index 228a2e064..6b9d4e868 100644
--- a/src/slang-nodes/StructMember.ts
+++ b/src/slang-nodes/StructMember.ts
@@ -5,7 +5,7 @@ import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,7 +31,7 @@ export class StructMember extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<StructMember>, print: PrintFunction): Doc {
-    return [path.call(print, 'typeName'), ' ', path.call(print, 'name'), ';'];
+  print(print: PrintFunction): Doc {
+    return [print('typeName'), ' ', print('name'), ';'];
   }
 }
diff --git a/src/slang-nodes/StructMembers.ts b/src/slang-nodes/StructMembers.ts
index 85ece3069..4b810b4fd 100644
--- a/src/slang-nodes/StructMembers.ts
+++ b/src/slang-nodes/StructMembers.ts
@@ -28,7 +28,7 @@ export class StructMembers extends SlangNode {
     );
   }
 
-  print(path: AstPath<StructMembers>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<StructMembers>): Doc {
     return this.items.length > 0
       ? printSeparatedList(path.map(print, 'items'), {
           firstSeparator: hardline,
diff --git a/src/slang-nodes/TryStatement.ts b/src/slang-nodes/TryStatement.ts
index ea562db86..d9f642a0a 100644
--- a/src/slang-nodes/TryStatement.ts
+++ b/src/slang-nodes/TryStatement.ts
@@ -10,7 +10,7 @@ import { Block } from './Block.js';
 import { CatchClauses } from './CatchClauses.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -51,16 +51,16 @@ export class TryStatement extends SlangNode {
     );
   }
 
-  print(path: AstPath<TryStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'try',
-      printSeparatedItem(path.call(print, 'expression'), {
+      printSeparatedItem(print('expression'), {
         firstSeparator: line
       }),
       joinExisting(' ', [
-        path.call(print, 'returns'),
-        path.call(print, 'body'),
-        path.call(print, 'catchClauses')
+        print('returns'),
+        print('body'),
+        print('catchClauses')
       ])
     ];
   }
diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts
index 025e40914..243f0d552 100644
--- a/src/slang-nodes/TupleDeconstructionElement.ts
+++ b/src/slang-nodes/TupleDeconstructionElement.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { TupleMember } from './TupleMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -29,7 +29,7 @@ export class TupleDeconstructionElement extends SlangNode {
     this.updateMetadata(this.member);
   }
 
-  print(path: AstPath<TupleDeconstructionElement>, print: PrintFunction): Doc {
-    return path.call(print, 'member');
+  print(print: PrintFunction): Doc {
+    return print('member');
   }
 }
diff --git a/src/slang-nodes/TupleDeconstructionElements.ts b/src/slang-nodes/TupleDeconstructionElements.ts
index b2c193600..d7595238f 100644
--- a/src/slang-nodes/TupleDeconstructionElements.ts
+++ b/src/slang-nodes/TupleDeconstructionElements.ts
@@ -25,7 +25,7 @@ export class TupleDeconstructionElements extends SlangNode {
     );
   }
 
-  print(path: AstPath<TupleDeconstructionElements>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<TupleDeconstructionElements>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/TupleDeconstructionStatement.ts b/src/slang-nodes/TupleDeconstructionStatement.ts
index 20c99f01a..1b2f79de7 100644
--- a/src/slang-nodes/TupleDeconstructionStatement.ts
+++ b/src/slang-nodes/TupleDeconstructionStatement.ts
@@ -6,7 +6,7 @@ import { TupleDeconstructionElements } from './TupleDeconstructionElements.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -39,13 +39,10 @@ export class TupleDeconstructionStatement extends SlangNode {
     this.updateMetadata(this.elements, this.expression);
   }
 
-  print(
-    path: AstPath<TupleDeconstructionStatement>,
-    print: PrintFunction
-  ): Doc {
+  print(print: PrintFunction): Doc {
     return printGroupAndIndentIfBreakPair(
-      [this.varKeyword ? 'var (' : '(', path.call(print, 'elements'), ') = '],
-      [path.call(print, 'expression'), ';']
+      [this.varKeyword ? 'var (' : '(', print('elements'), ') = '],
+      [print('expression'), ';']
     );
   }
 }
diff --git a/src/slang-nodes/TupleExpression.ts b/src/slang-nodes/TupleExpression.ts
index 6ba9fada2..ef6675f8d 100644
--- a/src/slang-nodes/TupleExpression.ts
+++ b/src/slang-nodes/TupleExpression.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { TupleValues } from './TupleValues.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class TupleExpression extends SlangNode {
     this.updateMetadata(this.items);
   }
 
-  print(path: AstPath<TupleExpression>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'items'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('items'), ')'];
   }
 }
diff --git a/src/slang-nodes/TupleValue.ts b/src/slang-nodes/TupleValue.ts
index e53997eaa..d7c38fc9f 100644
--- a/src/slang-nodes/TupleValue.ts
+++ b/src/slang-nodes/TupleValue.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -29,7 +29,7 @@ export class TupleValue extends SlangNode {
     this.updateMetadata(this.expression);
   }
 
-  print(path: AstPath<TupleValue>, print: PrintFunction): Doc {
-    return path.call(print, 'expression');
+  print(print: PrintFunction): Doc {
+    return print('expression');
   }
 }
diff --git a/src/slang-nodes/TupleValues.ts b/src/slang-nodes/TupleValues.ts
index 8170d81f9..abedde979 100644
--- a/src/slang-nodes/TupleValues.ts
+++ b/src/slang-nodes/TupleValues.ts
@@ -32,7 +32,7 @@ export class TupleValues extends SlangNode {
     return items.length === 1 ? items[0].expression : undefined;
   }
 
-  print(path: AstPath<TupleValues>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<TupleValues>): Doc {
     const singleExpression = this.getSingleExpression();
     const items = path.map(print, 'items');
     return singleExpression && isBinaryOperation(singleExpression)
diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts
index 44206a65c..fe680023c 100644
--- a/src/slang-nodes/TypeExpression.ts
+++ b/src/slang-nodes/TypeExpression.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -27,7 +27,7 @@ export class TypeExpression extends SlangNode {
     this.updateMetadata(this.typeName);
   }
 
-  print(path: AstPath<TypeExpression>, print: PrintFunction): Doc {
-    return ['type(', path.call(print, 'typeName'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['type(', print('typeName'), ')'];
   }
 }
diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts
index 3b2475910..b004f120c 100644
--- a/src/slang-nodes/TypedTupleMember.ts
+++ b/src/slang-nodes/TypedTupleMember.ts
@@ -7,7 +7,7 @@ import { StorageLocation } from './StorageLocation.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -41,11 +41,11 @@ export class TypedTupleMember extends SlangNode {
     this.updateMetadata(this.typeName, this.storageLocation);
   }
 
-  print(path: AstPath<TypedTupleMember>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(print, 'typeName'),
-      path.call(print, 'storageLocation'),
-      path.call(print, 'name')
+      print('typeName'),
+      print('storageLocation'),
+      print('name')
     ]);
   }
 }
diff --git a/src/slang-nodes/UncheckedBlock.ts b/src/slang-nodes/UncheckedBlock.ts
index 5aefd5516..fdfd66d7b 100644
--- a/src/slang-nodes/UncheckedBlock.ts
+++ b/src/slang-nodes/UncheckedBlock.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class UncheckedBlock extends SlangNode {
     this.updateMetadata(this.block);
   }
 
-  print(path: AstPath<UncheckedBlock>, print: PrintFunction): Doc {
-    return ['unchecked ', path.call(print, 'block')];
+  print(print: PrintFunction): Doc {
+    return ['unchecked ', print('block')];
   }
 }
diff --git a/src/slang-nodes/UnicodeStringLiterals.ts b/src/slang-nodes/UnicodeStringLiterals.ts
index 1df8cf928..f6a02c14a 100644
--- a/src/slang-nodes/UnicodeStringLiterals.ts
+++ b/src/slang-nodes/UnicodeStringLiterals.ts
@@ -27,7 +27,7 @@ export class UnicodeStringLiterals extends SlangNode {
     );
   }
 
-  print(path: AstPath<UnicodeStringLiterals>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<UnicodeStringLiterals>): Doc {
     return join(hardline, path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/UnnamedFunctionAttributes.ts b/src/slang-nodes/UnnamedFunctionAttributes.ts
index 1dcb079d7..dd3f99a0d 100644
--- a/src/slang-nodes/UnnamedFunctionAttributes.ts
+++ b/src/slang-nodes/UnnamedFunctionAttributes.ts
@@ -31,7 +31,7 @@ export class UnnamedFunctionAttributes extends SlangNode {
     this.items.sort(sortFunctionAttributes);
   }
 
-  print(path: AstPath<UnnamedFunctionAttributes>, print: PrintFunction): Doc {
-    return path.map(() => [line, print(path)], 'items');
+  print(print: PrintFunction, path: AstPath<UnnamedFunctionAttributes>): Doc {
+    return path.map(() => [line, print()], 'items');
   }
 }
diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts
index 29c2853c7..047f81efb 100644
--- a/src/slang-nodes/UnnamedFunctionDefinition.ts
+++ b/src/slang-nodes/UnnamedFunctionDefinition.ts
@@ -7,7 +7,7 @@ import { UnnamedFunctionAttributes } from './UnnamedFunctionAttributes.js';
 import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -48,7 +48,7 @@ export class UnnamedFunctionDefinition extends SlangNode {
     }
   }
 
-  print(path: AstPath<UnnamedFunctionDefinition>, print: PrintFunction): Doc {
-    return printFunctionWithBody('function', this, path, print);
+  print(print: PrintFunction): Doc {
+    return printFunctionWithBody('function', this, print);
   }
 }
diff --git a/src/slang-nodes/UntypedTupleMember.ts b/src/slang-nodes/UntypedTupleMember.ts
index 443cd6e68..3944e182c 100644
--- a/src/slang-nodes/UntypedTupleMember.ts
+++ b/src/slang-nodes/UntypedTupleMember.ts
@@ -5,7 +5,7 @@ import { StorageLocation } from './StorageLocation.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UntypedTupleMember extends SlangNode {
@@ -29,10 +29,7 @@ export class UntypedTupleMember extends SlangNode {
     this.updateMetadata(this.storageLocation);
   }
 
-  print(path: AstPath<UntypedTupleMember>, print: PrintFunction): Doc {
-    return joinExisting(' ', [
-      path.call(print, 'storageLocation'),
-      path.call(print, 'name')
-    ]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [print('storageLocation'), print('name')]);
   }
 }
diff --git a/src/slang-nodes/UserDefinedValueTypeDefinition.ts b/src/slang-nodes/UserDefinedValueTypeDefinition.ts
index 97ab74a22..6f7093034 100644
--- a/src/slang-nodes/UserDefinedValueTypeDefinition.ts
+++ b/src/slang-nodes/UserDefinedValueTypeDefinition.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { ElementaryType } from './ElementaryType.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UserDefinedValueTypeDefinition extends SlangNode {
@@ -29,16 +29,7 @@ export class UserDefinedValueTypeDefinition extends SlangNode {
     this.updateMetadata(this.valueType);
   }
 
-  print(
-    path: AstPath<UserDefinedValueTypeDefinition>,
-    print: PrintFunction
-  ): Doc {
-    return [
-      'type ',
-      path.call(print, 'name'),
-      ' is ',
-      path.call(print, 'valueType'),
-      ';'
-    ];
+  print(print: PrintFunction): Doc {
+    return ['type ', print('name'), ' is ', print('valueType'), ';'];
   }
 }
diff --git a/src/slang-nodes/UsingAlias.ts b/src/slang-nodes/UsingAlias.ts
index beed641a5..9a98047e5 100644
--- a/src/slang-nodes/UsingAlias.ts
+++ b/src/slang-nodes/UsingAlias.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { UsingOperator } from './UsingOperator.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingAlias extends SlangNode {
@@ -19,7 +19,7 @@ export class UsingAlias extends SlangNode {
     this.updateMetadata(this.operator);
   }
 
-  print(path: AstPath<UsingAlias>, print: PrintFunction): Doc {
-    return [' as ', path.call(print, 'operator')];
+  print(print: PrintFunction): Doc {
+    return [' as ', print('operator')];
   }
 }
diff --git a/src/slang-nodes/UsingDeconstruction.ts b/src/slang-nodes/UsingDeconstruction.ts
index 7d261c044..c02cb4119 100644
--- a/src/slang-nodes/UsingDeconstruction.ts
+++ b/src/slang-nodes/UsingDeconstruction.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { UsingDeconstructionSymbols } from './UsingDeconstructionSymbols.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingDeconstruction extends SlangNode {
@@ -19,7 +19,7 @@ export class UsingDeconstruction extends SlangNode {
     this.updateMetadata(this.symbols);
   }
 
-  print(path: AstPath<UsingDeconstruction>, print: PrintFunction): Doc {
-    return ['{', path.call(print, 'symbols'), '}'];
+  print(print: PrintFunction): Doc {
+    return ['{', print('symbols'), '}'];
   }
 }
diff --git a/src/slang-nodes/UsingDeconstructionSymbol.ts b/src/slang-nodes/UsingDeconstructionSymbol.ts
index edd7df842..f2ad39a62 100644
--- a/src/slang-nodes/UsingDeconstructionSymbol.ts
+++ b/src/slang-nodes/UsingDeconstructionSymbol.ts
@@ -4,7 +4,7 @@ import { IdentifierPath } from './IdentifierPath.js';
 import { UsingAlias } from './UsingAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingDeconstructionSymbol extends SlangNode {
@@ -28,7 +28,7 @@ export class UsingDeconstructionSymbol extends SlangNode {
     this.updateMetadata(this.name, this.alias);
   }
 
-  print(path: AstPath<UsingDeconstructionSymbol>, print: PrintFunction): Doc {
-    return [path.call(print, 'name'), path.call(print, 'alias')];
+  print(print: PrintFunction): Doc {
+    return [print('name'), print('alias')];
   }
 }
diff --git a/src/slang-nodes/UsingDeconstructionSymbols.ts b/src/slang-nodes/UsingDeconstructionSymbols.ts
index 91820a3e6..696a1d827 100644
--- a/src/slang-nodes/UsingDeconstructionSymbols.ts
+++ b/src/slang-nodes/UsingDeconstructionSymbols.ts
@@ -28,8 +28,8 @@ export class UsingDeconstructionSymbols extends SlangNode {
   }
 
   print(
-    path: AstPath<UsingDeconstructionSymbols>,
     print: PrintFunction,
+    path: AstPath<UsingDeconstructionSymbols>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return printSeparatedList(path.map(print, 'items'), {
diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts
index fe67a1162..cce80662b 100644
--- a/src/slang-nodes/UsingDirective.ts
+++ b/src/slang-nodes/UsingDirective.ts
@@ -5,7 +5,7 @@ import { UsingClause } from './UsingClause.js';
 import { UsingTarget } from './UsingTarget.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,12 +34,12 @@ export class UsingDirective extends SlangNode {
     this.updateMetadata(this.clause, this.target);
   }
 
-  print(path: AstPath<UsingDirective>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'using ',
-      path.call(print, 'clause'),
+      print('clause'),
       ' for ',
-      path.call(print, 'target'),
+      print('target'),
       this.globalKeyword ? ' global;' : ';'
     ];
   }
diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts
index ac9fb48d6..d47aad0a0 100644
--- a/src/slang-nodes/VariableDeclarationStatement.ts
+++ b/src/slang-nodes/VariableDeclarationStatement.ts
@@ -9,7 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 import { VariableDeclarationValue } from './VariableDeclarationValue.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -50,20 +50,15 @@ export class VariableDeclarationStatement extends SlangNode {
     this.updateMetadata(this.variableType, this.storageLocation, this.value);
   }
 
-  print(
-    path: AstPath<VariableDeclarationStatement>,
-    print: PrintFunction
-  ): Doc {
+  print(print: PrintFunction): Doc {
     return printGroupAndIndentIfBreakPair(
       [
-        path.call(print, 'variableType'),
-        this.storageLocation
-          ? indent([line, path.call(print, 'storageLocation')])
-          : '',
+        print('variableType'),
+        this.storageLocation ? indent([line, print('storageLocation')]) : '',
         ' ',
-        path.call(print, 'name')
+        print('name')
       ],
-      [path.call(print, 'value'), ';']
+      [print('value'), ';']
     );
   }
 }
diff --git a/src/slang-nodes/VariableDeclarationValue.ts b/src/slang-nodes/VariableDeclarationValue.ts
index 80415cd4e..5611189fb 100644
--- a/src/slang-nodes/VariableDeclarationValue.ts
+++ b/src/slang-nodes/VariableDeclarationValue.ts
@@ -5,7 +5,7 @@ import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -28,10 +28,10 @@ export class VariableDeclarationValue extends SlangNode {
     this.updateMetadata(this.expression);
   }
 
-  print(path: AstPath<VariableDeclarationValue>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       ' =',
-      printAssignmentRightSide(path.call(print, 'expression'), this.expression)
+      printAssignmentRightSide(print('expression'), this.expression)
     ];
   }
 }
diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts
index a364d8563..90a1917ef 100644
--- a/src/slang-nodes/VersionExpressionSet.ts
+++ b/src/slang-nodes/VersionExpressionSet.ts
@@ -23,7 +23,7 @@ export class VersionExpressionSet extends SlangNode {
     );
   }
 
-  print(path: AstPath<VersionExpressionSet>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<VersionExpressionSet>): Doc {
     return join(' ', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/VersionExpressionSets.ts b/src/slang-nodes/VersionExpressionSets.ts
index 3b72c95dc..6dbcb0855 100644
--- a/src/slang-nodes/VersionExpressionSets.ts
+++ b/src/slang-nodes/VersionExpressionSets.ts
@@ -22,7 +22,7 @@ export class VersionExpressionSets extends SlangNode {
     );
   }
 
-  print(path: AstPath<VersionExpressionSets>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<VersionExpressionSets>): Doc {
     return join(' || ', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/VersionPragma.ts b/src/slang-nodes/VersionPragma.ts
index 16e2c260d..51ce0e968 100644
--- a/src/slang-nodes/VersionPragma.ts
+++ b/src/slang-nodes/VersionPragma.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { VersionExpressionSets } from './VersionExpressionSets.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionPragma extends SlangNode {
@@ -19,7 +19,7 @@ export class VersionPragma extends SlangNode {
     this.updateMetadata(this.sets);
   }
 
-  print(path: AstPath<VersionPragma>, print: PrintFunction): Doc {
-    return ['solidity ', path.call(print, 'sets')];
+  print(print: PrintFunction): Doc {
+    return ['solidity ', print('sets')];
   }
 }
diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts
index a82085ab5..8b36accf9 100644
--- a/src/slang-nodes/VersionRange.ts
+++ b/src/slang-nodes/VersionRange.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { VersionLiteral } from './VersionLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionRange extends SlangNode {
@@ -23,7 +23,7 @@ export class VersionRange extends SlangNode {
     this.updateMetadata(this.start, this.end);
   }
 
-  print(path: AstPath<VersionRange>, print: PrintFunction): Doc {
-    return [path.call(print, 'start'), ' - ', path.call(print, 'end')];
+  print(print: PrintFunction): Doc {
+    return [print('start'), ' - ', print('end')];
   }
 }
diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts
index dd1362877..e24837cb9 100644
--- a/src/slang-nodes/VersionTerm.ts
+++ b/src/slang-nodes/VersionTerm.ts
@@ -5,7 +5,7 @@ import { VersionOperator } from './VersionOperator.js';
 import { VersionLiteral } from './VersionLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionTerm extends SlangNode {
@@ -26,7 +26,7 @@ export class VersionTerm extends SlangNode {
     this.updateMetadata(this.operator, this.literal);
   }
 
-  print(path: AstPath<VersionTerm>, print: PrintFunction): Doc {
-    return [path.call(print, 'operator'), path.call(print, 'literal')];
+  print(print: PrintFunction): Doc {
+    return [print('operator'), print('literal')];
   }
 }
diff --git a/src/slang-nodes/WhileStatement.ts b/src/slang-nodes/WhileStatement.ts
index 1b8cf3662..5c4bd8709 100644
--- a/src/slang-nodes/WhileStatement.ts
+++ b/src/slang-nodes/WhileStatement.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -33,13 +33,13 @@ export class WhileStatement extends SlangNode {
     this.updateMetadata(this.condition, this.body);
   }
 
-  print(path: AstPath<WhileStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'while (',
-      printSeparatedItem(path.call(print, 'condition')),
+      printSeparatedItem(print('condition')),
       ')',
       printIndentedGroupOrSpacedDocument(
-        path.call(print, 'body'),
+        print('body'),
         this.body.kind !== NonterminalKind.Block
       )
     ];
diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts
index 5cd7aac8f..9e19082eb 100644
--- a/src/slang-nodes/YulArguments.ts
+++ b/src/slang-nodes/YulArguments.ts
@@ -26,7 +26,7 @@ export class YulArguments extends SlangNode {
     );
   }
 
-  print(path: AstPath<YulArguments>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulArguments>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulBlock.ts b/src/slang-nodes/YulBlock.ts
index 4891f26c2..b7de9f754 100644
--- a/src/slang-nodes/YulBlock.ts
+++ b/src/slang-nodes/YulBlock.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { YulStatements } from './YulStatements.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class YulBlock extends SlangNode {
     this.updateMetadata(this.statements);
   }
 
-  print(path: AstPath<YulBlock>, print: PrintFunction): Doc {
-    return ['{', path.call(print, 'statements'), '}'];
+  print(print: PrintFunction): Doc {
+    return ['{', print('statements'), '}'];
   }
 }
diff --git a/src/slang-nodes/YulDefaultCase.ts b/src/slang-nodes/YulDefaultCase.ts
index 6f389ef20..72311ff26 100644
--- a/src/slang-nodes/YulDefaultCase.ts
+++ b/src/slang-nodes/YulDefaultCase.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -24,7 +24,7 @@ export class YulDefaultCase extends SlangNode {
     this.updateMetadata(this.body);
   }
 
-  print(path: AstPath<YulDefaultCase>, print: PrintFunction): Doc {
-    return ['default ', path.call(print, 'body')];
+  print(print: PrintFunction): Doc {
+    return ['default ', print('body')];
   }
 }
diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts
index 9a0dcf904..5232f88e7 100644
--- a/src/slang-nodes/YulForStatement.ts
+++ b/src/slang-nodes/YulForStatement.ts
@@ -6,7 +6,7 @@ import { YulBlock } from './YulBlock.js';
 import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -45,13 +45,13 @@ export class YulForStatement extends SlangNode {
     );
   }
 
-  print(path: AstPath<YulForStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return join(' ', [
       'for',
-      path.call(print, 'initialization'),
-      path.call(print, 'condition'),
-      path.call(print, 'iterator'),
-      path.call(print, 'body')
+      print('initialization'),
+      print('condition'),
+      print('iterator'),
+      print('body')
     ]);
   }
 }
diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts
index 07c3db27b..77c3d7829 100644
--- a/src/slang-nodes/YulFunctionCallExpression.ts
+++ b/src/slang-nodes/YulFunctionCallExpression.ts
@@ -5,7 +5,7 @@ import { YulExpression } from './YulExpression.js';
 import { YulArguments } from './YulArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,12 +31,7 @@ export class YulFunctionCallExpression extends SlangNode {
     this.updateMetadata(this.operand, this.arguments);
   }
 
-  print(path: AstPath<YulFunctionCallExpression>, print: PrintFunction): Doc {
-    return [
-      path.call(print, 'operand'),
-      '(',
-      path.call(print, 'arguments'),
-      ')'
-    ];
+  print(print: PrintFunction): Doc {
+    return [print('operand'), '(', print('arguments'), ')'];
   }
 }
diff --git a/src/slang-nodes/YulFunctionDefinition.ts b/src/slang-nodes/YulFunctionDefinition.ts
index d7ce7bdc9..17378284f 100644
--- a/src/slang-nodes/YulFunctionDefinition.ts
+++ b/src/slang-nodes/YulFunctionDefinition.ts
@@ -6,7 +6,7 @@ import { YulReturnsDeclaration } from './YulReturnsDeclaration.js';
 import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -38,13 +38,13 @@ export class YulFunctionDefinition extends SlangNode {
     this.updateMetadata(this.parameters, this.returns, this.body);
   }
 
-  print(path: AstPath<YulFunctionDefinition>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
       'function ',
-      path.call(print, 'name'),
-      path.call(print, 'parameters'),
-      path.call(print, 'returns') || ' ',
-      path.call(print, 'body')
+      print('name'),
+      print('parameters'),
+      print('returns') || ' ',
+      print('body')
     ];
   }
 }
diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts
index c92f90049..94ed7863e 100644
--- a/src/slang-nodes/YulIfStatement.ts
+++ b/src/slang-nodes/YulIfStatement.ts
@@ -5,7 +5,7 @@ import { YulExpression } from './YulExpression.js';
 import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -31,12 +31,7 @@ export class YulIfStatement extends SlangNode {
     this.updateMetadata(this.condition, this.body);
   }
 
-  print(path: AstPath<YulIfStatement>, print: PrintFunction): Doc {
-    return [
-      'if ',
-      path.call(print, 'condition'),
-      ' ',
-      path.call(print, 'body')
-    ];
+  print(print: PrintFunction): Doc {
+    return ['if ', print('condition'), ' ', print('body')];
   }
 }
diff --git a/src/slang-nodes/YulLabel.ts b/src/slang-nodes/YulLabel.ts
index dc2945967..04e2cfde0 100644
--- a/src/slang-nodes/YulLabel.ts
+++ b/src/slang-nodes/YulLabel.ts
@@ -4,7 +4,7 @@ import { SlangNode } from './SlangNode.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { dedent, line } = doc.builders;
@@ -20,7 +20,7 @@ export class YulLabel extends SlangNode {
     this.label = new TerminalNode(ast.label, collected);
   }
 
-  print(path: AstPath<YulLabel>, print: PrintFunction): Doc {
-    return [dedent(line), path.call(print, 'label'), ':'];
+  print(print: PrintFunction): Doc {
+    return [dedent(line), print('label'), ':'];
   }
 }
diff --git a/src/slang-nodes/YulParameters.ts b/src/slang-nodes/YulParameters.ts
index a8b1326c9..a6ad24c1f 100644
--- a/src/slang-nodes/YulParameters.ts
+++ b/src/slang-nodes/YulParameters.ts
@@ -18,7 +18,7 @@ export class YulParameters extends SlangNode {
     this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
-  print(path: AstPath<YulParameters>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulParameters>): Doc {
     return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulParametersDeclaration.ts b/src/slang-nodes/YulParametersDeclaration.ts
index 434223c50..5e055a1dd 100644
--- a/src/slang-nodes/YulParametersDeclaration.ts
+++ b/src/slang-nodes/YulParametersDeclaration.ts
@@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js';
 import { YulParameters } from './YulParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class YulParametersDeclaration extends SlangNode {
@@ -19,7 +19,7 @@ export class YulParametersDeclaration extends SlangNode {
     this.updateMetadata(this.parameters);
   }
 
-  print(path: AstPath<YulParametersDeclaration>, print: PrintFunction): Doc {
-    return ['(', path.call(print, 'parameters'), ')'];
+  print(print: PrintFunction): Doc {
+    return ['(', print('parameters'), ')'];
   }
 }
diff --git a/src/slang-nodes/YulPath.ts b/src/slang-nodes/YulPath.ts
index 7d9cd3e46..5612ef26b 100644
--- a/src/slang-nodes/YulPath.ts
+++ b/src/slang-nodes/YulPath.ts
@@ -20,7 +20,7 @@ export class YulPath extends SlangNode {
     this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
-  print(path: AstPath<YulPath>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulPath>): Doc {
     return join('.', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulPaths.ts b/src/slang-nodes/YulPaths.ts
index 8417011b0..c9235929e 100644
--- a/src/slang-nodes/YulPaths.ts
+++ b/src/slang-nodes/YulPaths.ts
@@ -20,7 +20,7 @@ export class YulPaths extends SlangNode {
     this.items = ast.items.map((item) => new YulPath(item, collected));
   }
 
-  print(path: AstPath<YulPaths>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulPaths>): Doc {
     return join(', ', path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulReturnsDeclaration.ts b/src/slang-nodes/YulReturnsDeclaration.ts
index 5866d3f3e..cba318c1a 100644
--- a/src/slang-nodes/YulReturnsDeclaration.ts
+++ b/src/slang-nodes/YulReturnsDeclaration.ts
@@ -5,7 +5,7 @@ import { SlangNode } from './SlangNode.js';
 import { YulVariableNames } from './YulVariableNames.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
@@ -23,8 +23,8 @@ export class YulReturnsDeclaration extends SlangNode {
     this.updateMetadata(this.variables);
   }
 
-  print(path: AstPath<YulReturnsDeclaration>, print: PrintFunction): Doc {
-    return printSeparatedItem(['->', path.call(print, 'variables')], {
+  print(print: PrintFunction): Doc {
+    return printSeparatedItem(['->', print('variables')], {
       firstSeparator: line
     });
   }
diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts
index f130e0e5e..edef0ef29 100644
--- a/src/slang-nodes/YulStackAssignmentStatement.ts
+++ b/src/slang-nodes/YulStackAssignmentStatement.ts
@@ -7,7 +7,7 @@ import { YulStackAssignmentOperator } from './YulStackAssignmentOperator.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
@@ -33,10 +33,10 @@ export class YulStackAssignmentStatement extends SlangNode {
     this.updateMetadata(this.assignment);
   }
 
-  print(path: AstPath<YulStackAssignmentStatement>, print: PrintFunction): Doc {
+  print(print: PrintFunction): Doc {
     return [
-      path.call(print, 'assignment'),
-      printSeparatedItem(path.call(print, 'variable'), {
+      print('assignment'),
+      printSeparatedItem(print('variable'), {
         firstSeparator: line,
         lastSeparator: ''
       })
diff --git a/src/slang-nodes/YulStatements.ts b/src/slang-nodes/YulStatements.ts
index a3e45bc4b..fdb0324ce 100644
--- a/src/slang-nodes/YulStatements.ts
+++ b/src/slang-nodes/YulStatements.ts
@@ -31,8 +31,8 @@ export class YulStatements extends SlangNode {
   }
 
   print(
-    path: AstPath<YulStatements>,
     print: PrintFunction,
+    path: AstPath<YulStatements>,
     options: ParserOptions<PrintableNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts
index ff6298cb3..8e4d60750 100644
--- a/src/slang-nodes/YulSwitchCases.ts
+++ b/src/slang-nodes/YulSwitchCases.ts
@@ -28,7 +28,7 @@ export class YulSwitchCases extends SlangNode {
     );
   }
 
-  print(path: AstPath<YulSwitchCases>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulSwitchCases>): Doc {
     return join(hardline, path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts
index 2ab25762e..3af7ac381 100644
--- a/src/slang-nodes/YulSwitchStatement.ts
+++ b/src/slang-nodes/YulSwitchStatement.ts
@@ -6,7 +6,7 @@ import { YulExpression } from './YulExpression.js';
 import { YulSwitchCases } from './YulSwitchCases.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -34,12 +34,7 @@ export class YulSwitchStatement extends SlangNode {
     this.updateMetadata(this.expression, this.cases);
   }
 
-  print(path: AstPath<YulSwitchStatement>, print: PrintFunction): Doc {
-    return [
-      'switch ',
-      path.call(print, 'expression'),
-      hardline,
-      path.call(print, 'cases')
-    ];
+  print(print: PrintFunction): Doc {
+    return ['switch ', print('expression'), hardline, print('cases')];
   }
 }
diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts
index 69dd4c398..0fa978503 100644
--- a/src/slang-nodes/YulValueCase.ts
+++ b/src/slang-nodes/YulValueCase.ts
@@ -5,7 +5,7 @@ import { YulLiteral } from './YulLiteral.js';
 import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -29,7 +29,7 @@ export class YulValueCase extends SlangNode {
     this.updateMetadata(this.value, this.body);
   }
 
-  print(path: AstPath<YulValueCase>, print: PrintFunction): Doc {
-    return ['case ', path.call(print, 'value'), ' ', path.call(print, 'body')];
+  print(print: PrintFunction): Doc {
+    return ['case ', print('value'), ' ', print('body')];
   }
 }
diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts
index 979f17e8c..ebee7c2b5 100644
--- a/src/slang-nodes/YulVariableAssignmentStatement.ts
+++ b/src/slang-nodes/YulVariableAssignmentStatement.ts
@@ -7,7 +7,7 @@ import { YulAssignmentOperator } from './YulAssignmentOperator.js';
 import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -40,14 +40,11 @@ export class YulVariableAssignmentStatement extends SlangNode {
     this.updateMetadata(this.variables, this.assignment, this.expression);
   }
 
-  print(
-    path: AstPath<YulVariableAssignmentStatement>,
-    print: PrintFunction
-  ): Doc {
+  print(print: PrintFunction): Doc {
     return join(' ', [
-      path.call(print, 'variables'),
-      path.call(print, 'assignment'),
-      path.call(print, 'expression')
+      print('variables'),
+      print('assignment'),
+      print('expression')
     ]);
   }
 }
diff --git a/src/slang-nodes/YulVariableDeclarationStatement.ts b/src/slang-nodes/YulVariableDeclarationStatement.ts
index 0d27331db..3b30265e8 100644
--- a/src/slang-nodes/YulVariableDeclarationStatement.ts
+++ b/src/slang-nodes/YulVariableDeclarationStatement.ts
@@ -5,7 +5,7 @@ import { YulVariableDeclarationValue } from './YulVariableDeclarationValue.js';
 import { YulVariableNames } from './YulVariableNames.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -35,13 +35,7 @@ export class YulVariableDeclarationStatement extends SlangNode {
     this.updateMetadata(this.value);
   }
 
-  print(
-    path: AstPath<YulVariableDeclarationStatement>,
-    print: PrintFunction
-  ): Doc {
-    return joinExisting(' ', [
-      ['let', path.call(print, 'variables')],
-      path.call(print, 'value')
-    ]);
+  print(print: PrintFunction): Doc {
+    return joinExisting(' ', [['let', print('variables')], print('value')]);
   }
 }
diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts
index 962f4a5bc..67b637580 100644
--- a/src/slang-nodes/YulVariableDeclarationValue.ts
+++ b/src/slang-nodes/YulVariableDeclarationValue.ts
@@ -5,7 +5,7 @@ import { YulAssignmentOperator } from './YulAssignmentOperator.js';
 import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { PrintableNode } from './types.d.ts';
 
@@ -33,11 +33,7 @@ export class YulVariableDeclarationValue extends SlangNode {
     this.updateMetadata(this.assignment, this.expression);
   }
 
-  print(path: AstPath<YulVariableDeclarationValue>, print: PrintFunction): Doc {
-    return [
-      path.call(print, 'assignment'),
-      ' ',
-      path.call(print, 'expression')
-    ];
+  print(print: PrintFunction): Doc {
+    return [print('assignment'), ' ', print('expression')];
   }
 }
diff --git a/src/slang-nodes/YulVariableNames.ts b/src/slang-nodes/YulVariableNames.ts
index 6a4ce473b..24797a0a8 100644
--- a/src/slang-nodes/YulVariableNames.ts
+++ b/src/slang-nodes/YulVariableNames.ts
@@ -21,7 +21,7 @@ export class YulVariableNames extends SlangNode {
     this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
-  print(path: AstPath<YulVariableNames>, print: PrintFunction): Doc {
+  print(print: PrintFunction, path: AstPath<YulVariableNames>): Doc {
     return printSeparatedList(path.map(print, 'items'), {
       firstSeparator: line,
       lastSeparator: ''
diff --git a/src/slang-printers/create-binary-operation-printer.ts b/src/slang-printers/create-binary-operation-printer.ts
index 7e65220ed..3c35f819a 100644
--- a/src/slang-printers/create-binary-operation-printer.ts
+++ b/src/slang-printers/create-binary-operation-printer.ts
@@ -14,7 +14,7 @@ function rightOperandPrint(
   print: PrintFunction,
   options: ParserOptions<PrintableNode>
 ): Doc {
-  const rightOperand = path.call(print, 'rightOperand');
+  const rightOperand = print('rightOperand');
   const rightOperandDoc =
     options.experimentalOperatorPosition === 'end'
       ? [` ${operator}`, line, rightOperand]
@@ -49,7 +49,7 @@ export const createBinaryOperationPrinter =
     const indentRules = indentRulesBuilder(node, path);
 
     return groupRules([
-      path.call(print, 'leftOperand'),
+      print('leftOperand'),
       indentRules(rightOperandPrint(node, path, print, options))
     ]);
   };
diff --git a/src/slang-printers/print-function.ts b/src/slang-printers/print-function.ts
index 2e835834f..46dd7e254 100644
--- a/src/slang-printers/print-function.ts
+++ b/src/slang-printers/print-function.ts
@@ -2,7 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { joinExisting } from '../slang-utils/join-existing.js';
 
-import type { AstPath, Doc } from 'prettier';
+import type { Doc } from 'prettier';
 import type { FunctionLike, FunctionWithBody } from '../slang-nodes/types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 
@@ -11,21 +11,17 @@ const { dedent, group, indent, line } = doc.builders;
 export function printFunction(
   functionName: Doc,
   node: FunctionLike,
-  path: AstPath<FunctionLike>,
   print: PrintFunction
 ): Doc {
-  const body = (node as FunctionWithBody).body;
-
   return group([
     functionName,
-    path.call(print, 'parameters'),
+    print('parameters'),
     indent(
       group([
-        joinExisting(line, [
-          path.call(print, 'attributes'),
-          path.call(print, 'returns')
-        ]),
-        body && body.kind === NonterminalKind.Block ? dedent(line) : ''
+        joinExisting(line, [print('attributes'), print('returns')]),
+        (node as FunctionWithBody).body?.kind === NonterminalKind.Block
+          ? dedent(line)
+          : ''
       ])
     )
   ]);
@@ -34,11 +30,7 @@ export function printFunction(
 export function printFunctionWithBody(
   functionName: Doc,
   node: FunctionLike,
-  path: AstPath<FunctionWithBody>,
   print: PrintFunction
 ): Doc {
-  return [
-    printFunction(functionName, node, path, print),
-    path.call(print, 'body')
-  ];
+  return [printFunction(functionName, node, print), print('body')];
 }
diff --git a/src/slang-printers/print-preserving-empty-lines.ts b/src/slang-printers/print-preserving-empty-lines.ts
index c3ac17ae5..ad79894c8 100644
--- a/src/slang-printers/print-preserving-empty-lines.ts
+++ b/src/slang-printers/print-preserving-empty-lines.ts
@@ -24,7 +24,7 @@ export function printPreservingEmptyLines(
           node.kind !== NonterminalKind.YulLabel
             ? hardline
             : '',
-          print(path),
+          print(),
           // Only attempt to append an empty line if `node` is not the last item
           !isLast &&
           // Append an empty line if the original text already had an one after the
diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts
index 919a5ef2c..dd5c1885c 100644
--- a/src/slangPrinter.ts
+++ b/src/slangPrinter.ts
@@ -12,7 +12,7 @@ function genericPrint(
   // Since each node has a print function with a specific AstPath, the union of
   // all nodes in PrintableNode creates a print function with an AstPath of the
   // intersection of all nodes. This forces us to cast this with a never type.
-  return path.node.print(path as AstPath<never>, print, options);
+  return path.node.print(print, path as AstPath<never>, options);
 }
 
 export default genericPrint;
diff --git a/src/types.d.ts b/src/types.d.ts
index f88e0b6b5..c57ae0502 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -24,7 +24,13 @@ interface AstLocation extends Location {
   outerEnd: number;
 }
 
-type PrintFunction = (path: AstPath<PrintableNode | undefined>) => Doc;
+type PrintFunction = (
+  selector?:
+    | string
+    | number
+    | (string | number)[]
+    | AstPath<PrintableNode | undefined>
+) => Doc;
 
 // This the union of all the types in the namespace `ast`.
 type TypeOfAst = typeof ast;