avoid calling path.node when we already have the reference

src/slang-nodes/ContractMembers.ts

@@ -36,9 +36,10 @@ export class ContractMembers extends SlangNode {
     options: ParserOptions<AstNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
-      ? printSeparatedItem(printPreservingEmptyLines(path, print, options), {
-          firstSeparator: hardline
-        })
+      ? printSeparatedItem(
+          printPreservingEmptyLines(this, path, print, options),
+          { firstSeparator: hardline }
+        )
       : '';
   }
 }

src/slang-nodes/InterfaceMembers.ts

@@ -36,9 +36,10 @@ export class InterfaceMembers extends SlangNode {
     options: ParserOptions<AstNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
-      ? printSeparatedItem(printPreservingEmptyLines(path, print, options), {
-          firstSeparator: hardline
-        })
+      ? printSeparatedItem(
+          printPreservingEmptyLines(this, path, print, options),
+          { firstSeparator: hardline }
+        )
       : '';
   }
 }

src/slang-nodes/LibraryMembers.ts

@@ -36,9 +36,10 @@ export class LibraryMembers extends SlangNode {
     options: ParserOptions<AstNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
-      ? printSeparatedItem(printPreservingEmptyLines(path, print, options), {
-          firstSeparator: hardline
-        })
+      ? printSeparatedItem(
+          printPreservingEmptyLines(this, path, print, options),
+          { firstSeparator: hardline }
+        )
       : '';
   }
 }

src/slang-nodes/MemberAccessExpression.ts

@@ -10,19 +10,18 @@ import { TerminalNode } from './TerminalNode.js';
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
-import type { AstNode } from './types.d.ts';
+import type { AstNode, ChainableExpression } from './types.d.ts';
 
 const { group, indent, label, softline } = doc.builders;
 
 function isEndOfChain(
-  node: MemberAccessExpression,
+  node: ChainableExpression,
   path: AstPath<Expression['variant']>
 ): boolean {
-  for (
-    let i = 1, current: Expression['variant'] = node, parent = path.getNode(i);
-    parent && isChainableExpression(parent);
-    i++, current = parent, parent = path.getNode(i)
-  ) {
+  for (let i = 1, current = node, parent; ; i++, current = parent) {
+    parent = path.getNode(i)!;
+    if (!isChainableExpression(parent)) break;
+
     switch (parent.kind) {
       case NonterminalKind.MemberAccessExpression:
         // If `parent` is a MemberAccessExpression we are not at the end

src/slang-nodes/Parameters.ts

@@ -36,7 +36,7 @@ export class Parameters extends SlangNode {
       return printSeparatedList(path.map(print, 'items'), { grouped: false });
     }
 
-    const parameterComments = printComments(path, options);
+    const parameterComments = printComments(this, path, options);
 
     return parameterComments.length > 0
       ? printSeparatedItem(parameterComments)

src/slang-nodes/PositionalArguments.ts

@@ -36,7 +36,7 @@ export class PositionalArguments extends SlangNode {
     if (this.items.length > 0) {
       return printSeparatedList(path.map(print, 'items'));
     }
-    const argumentComments = printComments(path, options);
+    const argumentComments = printComments(this, path, options);
 
     return argumentComments.length > 0
       ? printSeparatedItem(argumentComments)

src/slang-nodes/SourceUnitMembers.ts

@@ -31,6 +31,6 @@ export class SourceUnitMembers extends SlangNode {
     print: PrintFunction,
     options: ParserOptions<AstNode>
   ): Doc {
-    return printPreservingEmptyLines(path, print, options);
+    return printPreservingEmptyLines(this, path, print, options);
   }
 }

src/slang-nodes/Statements.ts

@@ -36,9 +36,10 @@ export class Statements extends SlangNode {
     options: ParserOptions<AstNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
-      ? printSeparatedItem(printPreservingEmptyLines(path, print, options), {
-          firstSeparator: hardline
-        })
+      ? printSeparatedItem(
+          printPreservingEmptyLines(this, path, print, options),
+          { firstSeparator: hardline }
+        )
       : '';
   }
 }

src/slang-nodes/YulStatements.ts

@@ -36,9 +36,10 @@ export class YulStatements extends SlangNode {
     options: ParserOptions<AstNode>
   ): Doc {
     return this.items.length > 0 || (this.comments?.length || 0) > 0
-      ? printSeparatedItem(printPreservingEmptyLines(path, print, options), {
-          firstSeparator: hardline
-        })
+      ? printSeparatedItem(
+          printPreservingEmptyLines(this, path, print, options),
+          { firstSeparator: hardline }
+        )
       : '';
   }
 }

src/slang-nodes/types.d.ts

@@ -494,6 +494,11 @@ export type BinaryOperation = Extract<
   }
 >;
 
+export type ChainableExpression =
+  | FunctionCallExpression
+  | IndexAccessExpression
+  | MemberAccessExpression;
+
 export type AstNode =
   | StrictAstNode
   | Comment

src/slang-printers/create-binary-operation-printer.ts

@@ -42,7 +42,8 @@ export const createBinaryOperationPrinter =
       path: AstPath<BinaryOperation>
     ) => (document: Doc) => Doc,
     indentRulesBuilder: (
-      path: AstPath<BinaryOperation>
+      node: BinaryOperation,
+      path: AstPath<StrictAstNode>
     ) => (document: Doc) => Doc
   ) =>
   (
@@ -52,7 +53,7 @@ export const createBinaryOperationPrinter =
     options: ParserOptions<AstNode>
   ): Doc => {
     const groupRules = groupRulesBuilder(path);
-    const indentRules = indentRulesBuilder(path);
+    const indentRules = indentRulesBuilder(node, path);
 
     return groupRules([
       path.call(print, 'leftOperand'),

src/slang-printers/print-binary-operation.ts

@@ -32,7 +32,7 @@ const isStatementWithoutIndentedOperation = createKindCheckFunction([
 
 export const shouldNotIndent = (
   node: StrictAstNode,
-  path: AstPath<BinaryOperation>,
+  path: AstPath<StrictAstNode>,
   index: number
 ): boolean =>
   isStatementWithoutIndentedOperation(node) ||
@@ -42,15 +42,14 @@ export const shouldNotIndent = (
 
 export const binaryIndentRulesBuilder =
   (shouldIndent: (node: BinaryOperation) => boolean) =>
-  (path: AstPath<BinaryOperation>) =>
+  (node: BinaryOperation, path: AstPath<StrictAstNode>) =>
   (document: Doc): Doc => {
-    for (let i = 1, node = path.node; ; i++) {
-      const parent = path.getNode(i) as StrictAstNode;
+    for (let i = 1, current = node, parent; ; i++, current = parent) {
+      parent = path.getNode(i)!;
       if (shouldNotIndent(parent, path, i)) break;
       if (!isBinaryOperation(parent)) return indent(document);
       if (shouldIndent(parent)) return indent(document);
-      if (node === parent.rightOperand) break;
-      node = parent;
+      if (current === parent.rightOperand) break;
     }
     return document;
   };

src/slang-printers/print-comments.ts

@@ -17,10 +17,11 @@ function isPrintable(comment: Comment): boolean {
 }
 
 export function printComments(
+  node: StrictAstNode,
   path: AstPath<StrictAstNode>,
   options: ParserOptions<AstNode>
 ): Doc[] {
-  if (path.node.comments === undefined) return [];
+  if (node.comments === undefined) return [];
   return joinExisting(
     line,
     path.map((commentPath, index, comments: Comment[]) => {

src/slang-printers/print-logical-operation.ts

@@ -15,19 +15,18 @@ const { indent } = doc.builders;
 const logicalGroupRulesBuilder = binaryGroupRulesBuilder(() => false);
 
 const logicalIndentRulesBuilder =
-  (path: AstPath<BinaryOperation>) =>
+  (node: BinaryOperation, path: AstPath<StrictAstNode>) =>
   (document: Doc): Doc => {
-    for (let i = 1, node = path.node; ; i++) {
-      const parent = path.getNode(i) as StrictAstNode;
+    for (let i = 1, current = node, parent; ; i++, current = parent) {
+      parent = path.getNode(i)!;
       if (shouldNotIndent(parent, path, i)) break;
       if (
         parent.kind === NonterminalKind.ConditionalExpression &&
-        parent.operand === node
+        parent.operand === current
       )
         break;
       if (!isBinaryOperation(parent)) return indent(document);
-      if (node === parent.rightOperand) break;
-      node = parent;
+      if (current === parent.rightOperand) break;
     }
     return document;
   };

src/slang-printers/print-preserving-empty-lines.ts

@@ -10,11 +10,12 @@ import type { PrintFunction } from '../types.d.ts';
 const { hardline } = doc.builders;
 
 export function printPreservingEmptyLines(
+  node: LineCollection,
   path: AstPath<LineCollection>,
   print: PrintFunction,
   options: ParserOptions<AstNode>
 ): Doc {
-  return path.node.items.length > 0
+  return node.items.length > 0
     ? path.map((childPath) => {
         const node = childPath.node;
 
@@ -35,5 +36,5 @@ export function printPreservingEmptyLines(
             : ''
         ];
       }, 'items')
-    : printComments(path, options);
+    : printComments(node, path, options);
 }

src/slang-utils/is-chainable-expression.ts

@@ -1,10 +1,11 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { createKindCheckFunction } from './create-kind-check-function.js';
 
+import type { ChainableExpression } from '../slang-nodes/types.js';
 import type { Expression } from '../slang-nodes/Expression.js';
 
 export const isChainableExpression = createKindCheckFunction([
   NonterminalKind.FunctionCallExpression,
   NonterminalKind.IndexAccessExpression,
   NonterminalKind.MemberAccessExpression
-]) as (node: Expression['variant']) => boolean;
+]) as (node: Expression['variant']) => node is ChainableExpression;