small cases where we gain from storing value in a variable

Author: Janther

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;

src/slang-nodes/AssignmentExpression.ts

@@ -31,12 +31,13 @@ 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)
+      rightOperandVariant.kind !== TerminalKind.Identifier &&
+      isBinaryOperation(rightOperandVariant)
         ? group(indent([line, rightOperand]))
         : [' ', rightOperand]
     ];

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.

src/slang-nodes/ContractSpecifiers.ts

@@ -28,9 +28,10 @@ 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');

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,

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

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(

src/slang-nodes/ReturnStatement.ts

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

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

@@ -13,24 +13,24 @@ 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 = path.call(print, 'rightOperand');
   const rightOperandDoc =
     options.experimentalOperatorPosition === 'end'
-      ? [` ${node.operator}`, line, rightOperand]
-      : [line, `${node.operator} `, 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);