Cleaning up duplicated code into a const (#1210)

Janther · web-flow · commit 254cff2d8747 · 2025-07-29T14:09:29.000+01:00
* storing printed node in const when it's used in a conditional operation

* the `flat()` call never does anything

* small cases where we gain from storing value in a variable

* spotted a `printSeparatedItem` pattern that I missed
diff --git a/src/clean.ts b/src/clean.ts
@@ -1,12 +1,5 @@
 // Prettier offers a clean way to define ignored properties.
-const ignoredProperties = new Set([
-  'loc',
-  'range',
-  'comments',
-  // this function is defined at constructor time so it won't pass AST
-  // comparisons.
-  'isEmpty'
-]);
+const ignoredProperties = new Set(['loc', 'range', 'comments']);
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 function clean(/* ast, newObj, parent */): void {}
 clean.ignoredProperties = ignoredProperties;
diff --git a/src/slang-nodes/AssignmentExpression.ts b/src/slang-nodes/AssignmentExpression.ts
@@ -31,13 +31,15 @@ export class AssignmentExpression extends SlangNode {
   }
 
   print(path: AstPath<AssignmentExpression>, print: PrintFunction): Doc {
+    const rightOperandVariant = this.rightOperand.variant;
+    const rightOperand = path.call(print, 'rightOperand');
     return [
       path.call(print, 'leftOperand'),
       ` ${this.operator}`,
-      this.rightOperand.variant.kind !== TerminalKind.Identifier &&
-      isBinaryOperation(this.rightOperand.variant)
-        ? group(indent([line, path.call(print, 'rightOperand')]))
-        : [' ', path.call(print, 'rightOperand')]
+      rightOperandVariant.kind !== TerminalKind.Identifier &&
+      isBinaryOperation(rightOperandVariant)
+        ? group(indent([line, rightOperand]))
+        : [' ', rightOperand]
     ];
   }
 }
diff --git a/src/slang-nodes/ConditionalExpression.ts b/src/slang-nodes/ConditionalExpression.ts
@@ -11,26 +11,20 @@ import type { PrintFunction } from '../types.d.ts';
 
 const { group, hardline, ifBreak, indent, line, softline } = doc.builders;
 
-function fillTab({ useTabs, tabWidth }: ParserOptions<AstNode>): Doc {
-  if (useTabs) return '\t';
-  // For the odd case of `tabWidth` of 1 or 0 we initiate `fillTab` as a single
-  // space.
-  return tabWidth > 2 ? ' '.repeat(tabWidth - 1) : ' ';
-}
-
 function experimentalTernaries(
   node: ConditionalExpression,
   path: AstPath<ConditionalExpression>,
   print: PrintFunction,
-  options: ParserOptions<AstNode>
+  { useTabs, tabWidth }: ParserOptions<AstNode>
 ): Doc {
   const grandparent = path.grandparent as StrictAstNode;
   const isNested = grandparent.kind === NonterminalKind.ConditionalExpression;
   const isNestedAsTrueExpression =
     isNested && grandparent.trueExpression.variant === node;
+  const falseExpressionVariantKind = node.falseExpression.variant.kind;
   const falseExpressionInSameLine =
-    node.falseExpression.variant.kind === NonterminalKind.TupleExpression ||
-    node.falseExpression.variant.kind === NonterminalKind.ConditionalExpression;
+    falseExpressionVariantKind === NonterminalKind.TupleExpression ||
+    falseExpressionVariantKind === NonterminalKind.ConditionalExpression;
 
   // If the `condition` breaks into multiple lines, we add parentheses,
   // unless it already is a `TupleExpression`.
@@ -56,14 +50,22 @@ function experimentalTernaries(
     { id: groupId }
   );
 
+  // For the odd case of `tabWidth` of 1 or 0 we initiate `fillTab` as a single
+  // space.
+  const fillTab = useTabs
+    ? '\t'
+    : tabWidth > 2
+      ? ' '.repeat(tabWidth - 1)
+      : ' ';
+
   const falseExpression = path.call(print, 'falseExpression');
   const falseExpressionDoc = [
     isNested ? hardline : line,
     ':',
     falseExpressionInSameLine
       ? [' ', falseExpression]
       : ifBreak(
-          [fillTab(options), indent(falseExpression)],
+          [fillTab, indent(falseExpression)],
           [' ', falseExpression],
           // We only add `fillTab` if we are sure the trueExpression is
           // indented.
diff --git a/src/slang-nodes/ContractSpecifiers.ts b/src/slang-nodes/ContractSpecifiers.ts
@@ -28,18 +28,16 @@ export class ContractSpecifiers extends SlangNode {
   }
 
   print(path: AstPath<ContractSpecifiers>, print: PrintFunction): Doc {
-    if (this.items.length === 0) return '';
-
     const [specifier1, specifier2] = path.map(print, 'items');
+
+    if (typeof specifier1 === 'undefined') return '';
+
     if (typeof specifier2 === 'undefined') return [' ', specifier1];
 
     const groupId = Symbol('Slang.ContractSpecifiers.inheritance');
     return printSeparatedList(
       [group(specifier1, { id: groupId }), specifier2],
-      {
-        firstSeparator: line,
-        separator: ifBreak('', softline, { groupId })
-      }
+      { firstSeparator: line, separator: ifBreak('', softline, { groupId }) }
     );
   }
 }
diff --git a/src/slang-nodes/DoWhileStatement.ts b/src/slang-nodes/DoWhileStatement.ts
@@ -10,7 +10,7 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 
-const { group, indent, line } = doc.builders;
+const { line } = doc.builders;
 
 export class DoWhileStatement extends SlangNode {
   readonly kind = NonterminalKind.DoWhileStatement;
@@ -29,11 +29,12 @@ export class DoWhileStatement extends SlangNode {
   }
 
   print(path: AstPath<DoWhileStatement>, print: PrintFunction): Doc {
+    const body = path.call(print, 'body');
     return [
       'do',
       this.body.variant.kind === NonterminalKind.Block
-        ? [' ', path.call(print, 'body'), ' ']
-        : group([indent([line, path.call(print, 'body')]), line]),
+        ? [' ', body, ' ']
+        : printSeparatedItem(body, { firstSeparator: line }),
       'while (',
       printSeparatedItem(path.call(print, 'condition')),
       ');'
diff --git a/src/slang-nodes/ElseBranch.ts b/src/slang-nodes/ElseBranch.ts
@@ -30,11 +30,12 @@ export class ElseBranch extends SlangNode {
   }
 
   print(path: AstPath<ElseBranch>, print: PrintFunction): Doc {
+    const body = path.call(print, 'body');
     return [
       'else',
       isIfStatementOrBlock(this.body.variant)
-        ? [' ', path.call(print, 'body')]
-        : group(indent([line, path.call(print, 'body')]))
+        ? [' ', body]
+        : group(indent([line, body]))
     ];
   }
 }
diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts
@@ -50,6 +50,7 @@ export class ForStatement extends SlangNode {
     const initialization = path.call(print, 'initialization');
     const condition = path.call(print, 'condition');
     const iterator = path.call(print, 'iterator');
+    const body = path.call(print, 'body');
 
     return [
       'for (',
@@ -61,8 +62,8 @@ export class ForStatement extends SlangNode {
       }),
       ')',
       this.body.variant.kind === NonterminalKind.Block
-        ? [' ', path.call(print, 'body')]
-        : group(indent([line, path.call(print, 'body')]))
+        ? [' ', body]
+        : group(indent([line, body]))
     ];
   }
 }
diff --git a/src/slang-nodes/FunctionCallExpression.ts b/src/slang-nodes/FunctionCallExpression.ts
@@ -32,21 +32,21 @@ export class FunctionCallExpression extends SlangNode {
   }
 
   print(path: AstPath<FunctionCallExpression>, print: PrintFunction): Doc {
-    const operandDoc = path.call(print, 'operand');
+    const operand = path.call(print, 'operand');
     const argumentsDoc = path.call(print, 'arguments');
 
     // If we are at the end of a MemberAccessChain we should indent the
     // arguments accordingly.
-    if (isLabel(operandDoc) && operandDoc.label === 'MemberAccessChain') {
+    if (isLabel(operand) && operand.label === 'MemberAccessChain') {
       const groupId = Symbol('Slang.FunctionCallExpression.operand');
       // We wrap the expression in a label in case there is an IndexAccess or
       // a FunctionCall following this IndexAccess.
       return label('MemberAccessChain', [
-        group(operandDoc.contents, { id: groupId }),
+        group(operand.contents, { id: groupId }),
         indentIfBreak(argumentsDoc, { groupId })
       ]);
     }
 
-    return [operandDoc, argumentsDoc].flat();
+    return [operand, argumentsDoc].flat();
   }
 }
diff --git a/src/slang-nodes/IfStatement.ts b/src/slang-nodes/IfStatement.ts
@@ -37,13 +37,14 @@ export class IfStatement extends SlangNode {
 
   print(path: AstPath<IfStatement>, print: PrintFunction): Doc {
     const { kind: bodyKind, comments: bodyComments } = this.body.variant;
+    const body = path.call(print, 'body');
     return [
       'if (',
       printSeparatedItem(path.call(print, 'condition')),
       ')',
       bodyKind === NonterminalKind.Block
-        ? [' ', path.call(print, 'body')]
-        : group(indent([line, path.call(print, 'body')]), {
+        ? [' ', body]
+        : group(indent([line, body]), {
             shouldBreak: bodyKind === NonterminalKind.IfStatement // `if` within `if`
           }),
       this.elseBranch
diff --git a/src/slang-nodes/IndexAccessExpression.ts b/src/slang-nodes/IndexAccessExpression.ts
@@ -37,7 +37,7 @@ export class IndexAccessExpression extends SlangNode {
   }
 
   print(path: AstPath<IndexAccessExpression>, print: PrintFunction): Doc {
-    const operandDoc = path.call(print, 'operand');
+    const operand = path.call(print, 'operand');
     const indexDoc = [
       '[',
       printSeparatedItem([path.call(print, 'start'), path.call(print, 'end')]),
@@ -46,16 +46,16 @@ export class IndexAccessExpression extends SlangNode {
 
     // If we are at the end of a MemberAccessChain we should indent the
     // arguments accordingly.
-    if (isLabel(operandDoc) && operandDoc.label === 'MemberAccessChain') {
+    if (isLabel(operand) && operand.label === 'MemberAccessChain') {
       const groupId = Symbol('Slang.IndexAccessExpression.operand');
       // We wrap the expression in a label in case there is an IndexAccess or
       // a FunctionCall following this IndexAccess.
       return label('MemberAccessChain', [
-        group(operandDoc.contents, { id: groupId }),
+        group(operand.contents, { id: groupId }),
         indentIfBreak(indexDoc, { groupId })
       ]);
     }
 
-    return [operandDoc, indexDoc].flat();
+    return [operand, indexDoc].flat();
   }
 }
diff --git a/src/slang-nodes/MemberAccessExpression.ts b/src/slang-nodes/MemberAccessExpression.ts
@@ -131,13 +131,8 @@ export class MemberAccessExpression extends SlangNode {
   }
 
   print(path: AstPath<MemberAccessExpression>, print: PrintFunction): Doc {
-    let operandDoc = path.call(print, 'operand');
-    if (Array.isArray(operandDoc)) {
-      operandDoc = operandDoc.flat();
-    }
-
     const document = [
-      operandDoc,
+      path.call(print, 'operand'),
       label('separator', [softline, '.']),
       path.call(print, 'member')
     ].flat();
diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts
@@ -36,8 +36,9 @@ export class ModifierDefinition extends SlangNode {
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
     if (!this.parameters) {
+      const attributesLoc = this.attributes.loc;
       const parametersOffset =
-        this.attributes.loc.start - this.attributes.loc.leadingOffset;
+        attributesLoc.start - attributesLoc.leadingOffset;
       const parametersLoc = {
         start: parametersOffset,
         end: parametersOffset,
diff --git a/src/slang-nodes/ModifierInvocation.ts b/src/slang-nodes/ModifierInvocation.ts
@@ -27,11 +27,12 @@ export class ModifierInvocation extends SlangNode {
   }
 
   cleanModifierInvocationArguments(): void {
+    const argumentsVariant = this.arguments?.variant;
     if (
-      this.arguments &&
-      this.arguments.variant.kind ===
+      argumentsVariant &&
+      argumentsVariant.kind ===
         NonterminalKind.PositionalArgumentsDeclaration &&
-      this.arguments.variant.isEmpty()
+      argumentsVariant.isEmpty
     ) {
       delete this.arguments;
     }
diff --git a/src/slang-nodes/PositionalArgumentsDeclaration.ts b/src/slang-nodes/PositionalArgumentsDeclaration.ts
@@ -27,11 +27,9 @@ export class PositionalArgumentsDeclaration extends SlangNode {
 
     // We need to check the comments at this point because they will be removed
     // from this node into the root node.
-    const empty =
+    this.isEmpty =
       this.arguments.items.length === 0 && // no arguments
       !this.comments.some((comment) => isBlockComment(comment)); // no block comments
-
-    this.isEmpty = (): boolean => empty;
   }
 
   print(
diff --git a/src/slang-nodes/ReturnStatement.ts b/src/slang-nodes/ReturnStatement.ts
@@ -16,13 +16,14 @@ function printExpression(
   print: PrintFunction,
   options: ParserOptions<AstNode>
 ): Doc {
-  const expressionVariant = node.expression?.variant;
-  if (expressionVariant) {
-    return expressionVariant.kind === NonterminalKind.TupleExpression ||
+  const expressionVariantKind = node.expression?.variant.kind;
+  const expression = path.call(print, 'expression');
+  if (expressionVariantKind) {
+    return expressionVariantKind === NonterminalKind.TupleExpression ||
       (options.experimentalTernaries &&
-        expressionVariant.kind === NonterminalKind.ConditionalExpression)
-      ? [' ', path.call(print, 'expression')]
-      : group(indent([line, path.call(print, 'expression')]));
+        expressionVariantKind === NonterminalKind.ConditionalExpression)
+      ? [' ', expression]
+      : group(indent([line, expression]));
   }
   return '';
 }
diff --git a/src/slang-nodes/StateVariableDefinitionValue.ts b/src/slang-nodes/StateVariableDefinitionValue.ts
@@ -30,8 +30,9 @@ export class StateVariableDefinitionValue extends SlangNode {
     path: AstPath<StateVariableDefinitionValue>,
     print: PrintFunction
   ): Doc {
+    const value = path.call(print, 'value');
     return this.value.variant.kind === NonterminalKind.ArrayExpression
-      ? [' = ', path.call(print, 'value')]
-      : group([' =', indent([line, path.call(print, 'value')])]);
+      ? [' = ', value]
+      : group([' =', indent([line, value])]);
   }
 }
diff --git a/src/slang-nodes/TupleValues.ts b/src/slang-nodes/TupleValues.ts
@@ -30,10 +30,11 @@ export class TupleValues extends SlangNode {
 
   print(path: AstPath<TupleValues>, print: PrintFunction): Doc {
     const singleExpressionVariant = this.getSingleExpression()?.variant;
+    const items = path.map(print, 'items');
     return singleExpressionVariant &&
       singleExpressionVariant.kind !== TerminalKind.Identifier &&
       isBinaryOperation(singleExpressionVariant)
-      ? path.map(print, 'items')
-      : printSeparatedList(path.map(print, 'items'));
+      ? items
+      : printSeparatedList(items);
   }
 }
diff --git a/src/slang-nodes/WhileStatement.ts b/src/slang-nodes/WhileStatement.ts
@@ -29,13 +29,14 @@ export class WhileStatement extends SlangNode {
   }
 
   print(path: AstPath<WhileStatement>, print: PrintFunction): Doc {
+    const body = path.call(print, 'body');
     return [
       'while (',
       printSeparatedItem(path.call(print, 'condition')),
       ')',
       this.body.variant.kind === NonterminalKind.Block
-        ? [' ', path.call(print, 'body')]
-        : group(indent([line, path.call(print, 'body')]))
+        ? [' ', body]
+        : group(indent([line, body]))
     ];
   }
 }
diff --git a/src/slang-printers/create-binary-operation-printer.ts b/src/slang-printers/create-binary-operation-printer.ts
@@ -13,27 +13,28 @@ import type { PrintFunction } from '../types.d.ts';
 const { group, line } = doc.builders;
 
 function rightOperandPrint(
-  node: BinaryOperation,
+  { operator, leftOperand }: BinaryOperation,
   path: AstPath<BinaryOperation>,
   print: PrintFunction,
   options: ParserOptions<AstNode>
 ): Doc {
-  const rightOperand =
+  const rightOperand = path.call(print, 'rightOperand');
+  const rightOperandDoc =
     options.experimentalOperatorPosition === 'end'
-      ? [` ${node.operator}`, line, path.call(print, 'rightOperand')]
-      : [line, `${node.operator} `, path.call(print, 'rightOperand')];
+      ? [` ${operator}`, line, rightOperand]
+      : [line, `${operator} `, rightOperand];
 
   // If there's only a single binary expression, we want to create a group in
   // order to avoid having a small right part like -1 be on its own line.
-  const leftOperand = node.leftOperand.variant;
+  const leftOperandVariant = leftOperand.variant;
   const grandparentNode = path.grandparent as StrictAstNode;
   const shouldGroup =
-    (leftOperand.kind === TerminalKind.Identifier ||
-      !isBinaryOperation(leftOperand)) &&
+    (leftOperandVariant.kind === TerminalKind.Identifier ||
+      !isBinaryOperation(leftOperandVariant)) &&
     (!isBinaryOperation(grandparentNode) ||
       grandparentNode.kind === NonterminalKind.AssignmentExpression);
 
-  return shouldGroup ? group(rightOperand) : rightOperand;
+  return shouldGroup ? group(rightOperandDoc) : rightOperandDoc;
 }
 
 export const createBinaryOperationPrinter =

Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,15 @@ export class AssignmentExpression extends SlangNode {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`print(path: AstPath<AssignmentExpression>, print: PrintFunction): Doc {`
	`34`	`+ const rightOperandVariant = this.rightOperand.variant;`
	`35`	`+ const rightOperand = path.call(print, 'rightOperand');`
`34`	`36`	`return [`
`35`	`37`	`path.call(print, 'leftOperand'),`
`36`	`38`	` ${this.operator}`,
`37`		`- this.rightOperand.variant.kind !== TerminalKind.Identifier &&`
`38`		`- isBinaryOperation(this.rightOperand.variant)`
`39`		`- ? group(indent([line, path.call(print, 'rightOperand')]))`
`40`		`- : [' ', path.call(print, 'rightOperand')]`
	`39`	`+ rightOperandVariant.kind !== TerminalKind.Identifier &&`
	`40`	`+ isBinaryOperation(rightOperandVariant)`
	`41`	`+ ? group(indent([line, rightOperand]))`
	`42`	`+ : [' ', rightOperand]`
`41`	`43`	`];`
`42`	`44`	`}`
`43`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,12 @@ export class ElseBranch extends SlangNode {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`print(path: AstPath<ElseBranch>, print: PrintFunction): Doc {`
	`33`	`+ const body = path.call(print, 'body');`
`33`	`34`	`return [`
`34`	`35`	`'else',`
`35`	`36`	`isIfStatementOrBlock(this.body.variant)`
`36`		`- ? [' ', path.call(print, 'body')]`
`37`		`- : group(indent([line, path.call(print, 'body')]))`
	`37`	`+ ? [' ', body]`
	`38`	`+ : group(indent([line, body]))`
`38`	`39`	`];`
`39`	`40`	`}`
`40`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,21 +32,21 @@ export class FunctionCallExpression extends SlangNode {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`print(path: AstPath<FunctionCallExpression>, print: PrintFunction): Doc {`
`35`		`- const operandDoc = path.call(print, 'operand');`
	`35`	`+ const operand = path.call(print, 'operand');`
`36`	`36`	`const argumentsDoc = path.call(print, 'arguments');`
`37`	`37`
`38`	`38`	`// If we are at the end of a MemberAccessChain we should indent the`
`39`	`39`	`// arguments accordingly.`
`40`		`- if (isLabel(operandDoc) && operandDoc.label === 'MemberAccessChain') {`
	`40`	`+ if (isLabel(operand) && operand.label === 'MemberAccessChain') {`
`41`	`41`	`const groupId = Symbol('Slang.FunctionCallExpression.operand');`
`42`	`42`	`// We wrap the expression in a label in case there is an IndexAccess or`
`43`	`43`	`// a FunctionCall following this IndexAccess.`
`44`	`44`	`return label('MemberAccessChain', [`
`45`		`- group(operandDoc.contents, { id: groupId }),`
	`45`	`+ group(operand.contents, { id: groupId }),`
`46`	`46`	`indentIfBreak(argumentsDoc, { groupId })`
`47`	`47`	`]);`
`48`	`48`	`}`
`49`	`49`
`50`		`- return [operandDoc, argumentsDoc].flat();`
	`50`	`+ return [operand, argumentsDoc].flat();`
`51`	`51`	`}`
`52`	`52`	`}`