other destructuring and variable caching that where missing

Author: Janther

src/index.ts

@@ -51,10 +51,8 @@ const parsers = {
   [antlrParserId]: antlrParser
 };
 
-const antlrCanAttachComment = (node: { type: string }): boolean =>
-  typeof node.type === 'string' &&
-  node.type !== 'BlockComment' &&
-  node.type !== 'LineComment';
+const antlrCanAttachComment = ({ type }: { type: string }): boolean =>
+  typeof type === 'string' && type !== 'BlockComment' && type !== 'LineComment';
 const canAttachComment = (node: AstNode): boolean =>
   typeof node !== 'string' &&
   typeof node !== 'undefined' &&

src/slang-nodes/ConditionalExpression.ts

@@ -11,11 +11,11 @@ import type { PrintFunction, SlangNode } from '../types.d.ts';
 
 const { group, hardline, ifBreak, indent, line, softline } = doc.builders;
 
-function fillTab(options: ParserOptions<AstNode>): Doc {
-  if (options.useTabs) return '\t';
+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 options.tabWidth > 2 ? ' '.repeat(options.tabWidth - 1) : ' ';
+  return tabWidth > 2 ? ' '.repeat(tabWidth - 1) : ' ';
 }
 
 function experimentalTernaries(

src/slang-nodes/IfStatement.ts

@@ -47,19 +47,20 @@ export class IfStatement implements SlangNode {
   }
 
   print(path: AstPath<IfStatement>, print: PrintFunction): Doc {
+    const { kind: bodyKind, comments: bodyComments } = this.body.variant;
     return [
       'if (',
       printSeparatedItem(path.call(print, 'condition')),
       ')',
-      this.body.variant.kind === NonterminalKind.Block
+      bodyKind === NonterminalKind.Block
         ? [' ', path.call(print, 'body')]
         : group(indent([line, path.call(print, 'body')]), {
-            shouldBreak: this.body.variant.kind === NonterminalKind.IfStatement // `if` within `if`
+            shouldBreak: bodyKind === NonterminalKind.IfStatement // `if` within `if`
           }),
       this.elseBranch
         ? [
-            this.body.variant.kind !== NonterminalKind.Block || // else on a new line if body is not a block
-            this.body.variant.comments.some(
+            bodyKind !== NonterminalKind.Block || // else on a new line if body is not a block
+            bodyComments.some(
               (comment) =>
                 !isBlockComment(comment) || comment.placement === 'ownLine'
             ) // or if body has trailing single line comments or a block comment on a new line

src/slang-nodes/ReturnStatement.ts

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

src/slang-utils/create-hug-function.ts

@@ -10,10 +10,11 @@ export function createHugFunction(
 ): (node: Expression) => Expression {
   const operators = new Set(huggableOperators);
   return (node: Expression): Expression => {
+    const { variant } = node;
     if (
-      node.variant.kind !== TerminalKind.Identifier &&
-      isBinaryOperation(node.variant) &&
-      operators.has(node.variant.operator)
+      variant.kind !== TerminalKind.Identifier &&
+      isBinaryOperation(variant) &&
+      operators.has(variant.operator)
     ) {
       const { loc } = node;
 

src/slang-utils/metadata.ts

@@ -144,11 +144,11 @@ export function updateMetadata(
     for (const childNode of childNodes) {
       if (typeof childNode === 'undefined' || Array.isArray(childNode))
         continue;
-      const childLoc = childNode.loc;
+      const { leadingOffset, start } = childNode.loc;
 
-      if (childLoc.start - childLoc.leadingOffset === loc.start) {
-        loc.leadingOffset = childLoc.leadingOffset;
-        loc.start += childLoc.leadingOffset;
+      if (start - leadingOffset === loc.start) {
+        loc.leadingOffset = leadingOffset;
+        loc.start += leadingOffset;
         break;
       }
     }
@@ -158,11 +158,11 @@ export function updateMetadata(
     for (const childNode of childNodes.reverse()) {
       if (typeof childNode === 'undefined' || Array.isArray(childNode))
         continue;
-      const childLoc = childNode.loc;
+      const { trailingOffset, end } = childNode.loc;
 
-      if (childLoc.end + childLoc.trailingOffset === loc.end) {
-        loc.trailingOffset = childLoc.trailingOffset;
-        loc.end -= childLoc.trailingOffset;
+      if (end + trailingOffset === loc.end) {
+        loc.trailingOffset = trailingOffset;
+        loc.end -= trailingOffset;
         break;
       }
     }

src/slang-utils/sort-contract-specifiers.ts

@@ -3,21 +3,18 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import type { ContractSpecifier } from '../slang-nodes/ContractSpecifier.js';
 
 export function sortContractSpecifiers(
-  a: ContractSpecifier,
-  b: ContractSpecifier
+  { variant: { kind: aKind } }: ContractSpecifier,
+  { variant: { kind: bKind } }: ContractSpecifier
 ): number {
-  const aVariant = a.variant;
-  const bVariant = b.variant;
-
   // OverrideSpecifiers before ModifierInvocation
   if (
-    aVariant.kind === NonterminalKind.InheritanceSpecifier &&
-    bVariant.kind === NonterminalKind.StorageLayoutSpecifier
+    aKind === NonterminalKind.InheritanceSpecifier &&
+    bKind === NonterminalKind.StorageLayoutSpecifier
   )
     return -1;
   if (
-    bVariant.kind === NonterminalKind.InheritanceSpecifier &&
-    aVariant.kind === NonterminalKind.StorageLayoutSpecifier
+    bKind === NonterminalKind.InheritanceSpecifier &&
+    aKind === NonterminalKind.StorageLayoutSpecifier
   )
     return 1;
 

src/slang-utils/sort-function-attributes.ts

@@ -12,12 +12,9 @@ const visibilityKeyWords = new Set([
 const mutabilityKeyWords = new Set(['pure', 'constant', 'payable', 'view']);
 
 export function sortFunctionAttributes(
-  a: SortableAttribute,
-  b: SortableAttribute
+  { variant: aVariant }: SortableAttribute,
+  { variant: bVariant }: SortableAttribute
 ): number {
-  const aVariant = a.variant;
-  const bVariant = b.variant;
-
   const aIsString = typeof aVariant === 'string';
   const bIsString = typeof bVariant === 'string';
 

src/slangPrinter.ts

@@ -5,12 +5,12 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode, StrictAstNode } from './slang-nodes/types.d.ts';
 import type { PrintFunction } from './types.d.ts';
 
-function hasNodeIgnoreComment(node: StrictAstNode): boolean {
+function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean {
   // Prettier sets SourceUnit's comments to undefined after assigning comments
   // to each node.
   return (
-    node.comments &&
-    node.comments.some(
+    comments &&
+    comments.some(
       (comment) =>
         comment.value
           .slice(2, isBlockComment(comment) ? -2 : undefined)