storing printed node in const when it's used in a conditional operation

Author: Janther

src/slang-nodes/AssignmentExpression.ts

@@ -31,13 +31,14 @@ export class AssignmentExpression extends SlangNode {
   }
 
   print(path: AstPath<AssignmentExpression>, print: PrintFunction): Doc {
+    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')]
+        ? group(indent([line, rightOperand]))
+        : [' ', rightOperand]
     ];
   }
 }

src/slang-nodes/DoWhileStatement.ts

@@ -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, ' ']
+        : group([indent([line, body]), line]),
       'while (',
       printSeparatedItem(path.call(print, 'condition')),
       ');'

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]))
     ];
   }
 }

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]))
     ];
   }
 }

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();
   }
 }

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

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();
   }
 }

src/slang-nodes/ReturnStatement.ts

@@ -17,12 +17,13 @@ function printExpression(
   options: ParserOptions<AstNode>
 ): Doc {
   const expressionVariant = node.expression?.variant;
+  const expression = path.call(print, 'expression');
   if (expressionVariant) {
     return expressionVariant.kind === NonterminalKind.TupleExpression ||
       (options.experimentalTernaries &&
         expressionVariant.kind === NonterminalKind.ConditionalExpression)
-      ? [' ', path.call(print, 'expression')]
-      : group(indent([line, path.call(print, 'expression')]));
+      ? [' ', expression]
+      : group(indent([line, expression]));
   }
   return '';
 }

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])]);
   }
 }

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]))
     ];
   }
 }