Chain behaviour closer to prettier core (#560)

* new chain behaviour is decoupled from the format of the first element of the chain

* a nicer way to do this filter

* documentation changes

* removing extra 'and'

Author: Janther

src/nodes/FunctionCall.js

@@ -1,58 +1,41 @@
 const {
   doc: {
-    builders: { label, line, softline }
+    builders: { line, softline }
   }
 } = require('prettier');
 
 const printSeparatedList = require('./print-separated-list');
 
-let functionCallId = 0;
-
-const printObject = (node, path, print, options, groupId) => [
+const printObject = (node, path, print, options) => [
   '{',
   printSeparatedList(
     path
       .map(print, 'arguments')
       .map((arg, index) => [node.names[index], ': ', arg]),
     {
-      groupId,
       firstSeparator: options.bracketSpacing ? line : softline,
       lastSeparator: [options.bracketSpacing ? line : softline, '})']
     }
   )
 ];
 
-const printArguments = (path, print, groupId) =>
+const printArguments = (path, print) =>
   printSeparatedList(path.map(print, 'arguments'), {
-    groupId,
     lastSeparator: [softline, ')']
   });
 
 const FunctionCall = {
   print: ({ node, path, print, options }) => {
     let argumentsDoc = ')';
-    const functionCallLabel = { type: 'FunctionCall', groupId: null };
     if (node.arguments && node.arguments.length > 0) {
-      functionCallLabel.groupId = `FunctionCall-${functionCallId}`;
-      functionCallId += 1;
       if (node.names && node.names.length > 0) {
-        argumentsDoc = printObject(
-          node,
-          path,
-          print,
-          options,
-          functionCallLabel.groupId
-        );
+        argumentsDoc = printObject(node, path, print, options);
       } else {
-        argumentsDoc = printArguments(path, print, functionCallLabel.groupId);
+        argumentsDoc = printArguments(path, print);
       }
     }
 
-    return label(JSON.stringify(functionCallLabel), [
-      path.call(print, 'expression'),
-      '(',
-      argumentsDoc
-    ]);
+    return [path.call(print, 'expression'), '(', argumentsDoc];
   }
 };
 

src/nodes/IndexAccess.js

@@ -1,28 +1,15 @@
 const {
   doc: {
-    builders: { group, indent, label, softline }
+    builders: { group, indent, softline }
   }
 } = require('prettier');
 
-let indexAccessId = 0;
-
 const IndexAccess = {
-  print: ({ path, print }) => {
-    const indexAccessLabel = {
-      type: 'IndexAccess',
-      groupId: `IndexAccess-${indexAccessId}`
-    };
-    indexAccessId += 1;
-
-    return label(JSON.stringify(indexAccessLabel), [
-      path.call(print, 'base'),
-      '[',
-      group([indent([softline, path.call(print, 'index')]), softline], {
-        id: indexAccessLabel.groupId
-      }),
-      ']'
-    ]);
-  }
+  print: ({ path, print }) => [
+    path.call(print, 'base'),
+    '[',
+    group([indent([softline, path.call(print, 'index')]), softline, ']'])
+  ]
 };
 
 module.exports = IndexAccess;

src/nodes/MemberAccess.js

@@ -1,6 +1,6 @@
 const {
   doc: {
-    builders: { group, ifBreak, indent, label, softline }
+    builders: { group, indent, label, softline }
   }
 } = require('prettier');
 
@@ -55,15 +55,22 @@ const isEndOfChain = (node, path) => {
  * first separator.
  * The second array contains the rest of the chain.
  *
- * The indentation of the whole chain depends on the result of the first
- * element.
+ * The second array is grouped and indented, while the first element's
+ * formatting logic remains separated.
  *
- * If the first element breaks into multiple lines, we won't indent the rest of
- * the chain as the last line (most likely a closing parentheses) won't be
- * indented.
+ * That way the first element can safely split into multiple lines and the rest
+ * of the chain will continue its formatting rules as normal.
  *
  * i.e.
  * ```
+ * functionCall(arg1, arg2).rest.of.chain
+ *
+ * functionCall(arg1, arg2)
+ *     .long
+ *     .rest
+ *     .of
+ *     .chain
+ *
  * functionCall(
  *     arg1,
  *     arg2
@@ -73,21 +80,6 @@ const isEndOfChain = (node, path) => {
  *     arg1,
  *     arg2
  * )
- * .long
- * .rest
- * .of
- * .chain
- * ```
- *
- * If the first element doesn't break into multiple lines we treat the rest of
- * the chain as a normal chain and proceed to indent it.
- *
- *
- * i.e.
- * ```
- * a = functionCall(arg1, arg2).rest.of.chain
- *
- * b = functionCall(arg1, arg2)
  *     .long
  *     .rest
  *     .of
@@ -102,51 +94,31 @@ const isEndOfChain = (node, path) => {
  * be printed.
  */
 const processChain = (chain) => {
-  const firstSeparatorIndex = chain.findIndex((element) => {
-    if (element.label) {
-      return JSON.parse(element.label).type === 'separator';
-    }
-    return false;
-  });
-  // We fetch the groupId from the firstSeparator
-  const { groupId } = JSON.parse(chain[firstSeparatorIndex].label);
+  const firstSeparatorIndex = chain.findIndex(
+    (element) => element.label === 'separator'
+  );
   // The doc[] before the first separator
   const firstExpression = chain.slice(0, firstSeparatorIndex);
   // The doc[] containing the rest of the chain
-  const restOfChain = group(chain.slice(firstSeparatorIndex));
+  const restOfChain = group(indent(chain.slice(firstSeparatorIndex)));
 
-  return groupId
-    ? [
-        ...firstExpression,
-        ifBreak(restOfChain, indent(restOfChain), { groupId })
-      ]
-    : [...firstExpression, indent(restOfChain)];
+  return group([firstExpression, restOfChain]);
 };
 
 const MemberAccess = {
   print: ({ node, path, print }) => {
     let expressionDoc = path.call(print, 'expression');
-    const separatorLabel = {
-      type: 'separator'
-    };
-
-    if (expressionDoc.label) {
-      const labelData = JSON.parse(expressionDoc.label);
-      if (labelData && labelData.groupId) {
-        // if there's a groupId in the data, we pass it to the separator as
-        // this doc[] is going to be stripped of it's metadata
-        separatorLabel.groupId = labelData.groupId;
-      }
-      expressionDoc = expressionDoc.contents.flat();
+    if (Array.isArray(expressionDoc)) {
+      expressionDoc = expressionDoc.flat();
     }
 
     const doc = [
       expressionDoc,
-      label(JSON.stringify(separatorLabel), [softline, '.']),
+      label('separator', [softline, '.']),
       node.memberName
     ].flat();
 
-    return isEndOfChain(node, path) ? group(processChain(doc)) : doc;
+    return isEndOfChain(node, path) ? processChain(doc) : doc;
   }
 };
 

src/nodes/print-comments.js

@@ -20,7 +20,7 @@ const printComments = (node, path, options, filter = () => true) =>
             comment.printed = true;
             return options.printer.printComment(commentPath);
           }, 'comments')
-          .filter((element) => element)
+          .filter(Boolean)
       )
     : '';
 

src/nodes/print-separated-list.js

@@ -14,14 +14,9 @@ const {
 const printSeparatedList = (
   list,
   {
-    groupId,
     firstSeparator = softline,
     separator = [',', line],
     lastSeparator = firstSeparator
   } = {}
-) =>
-  group(
-    [indent([firstSeparator, join(separator, list)]), lastSeparator],
-    groupId ? { id: groupId } : {}
-  );
+) => group([indent([firstSeparator, join(separator, list)]), lastSeparator]);
 module.exports = printSeparatedList;