Change formatting of lists

To allow forcing a list on multiple lines based on the presence of a
trailing comma

compiler-core/src/format.rs

···
             };
         }
 
-        let comma = match elements.first() {
-            // If the list is made of non-simple constants and it gets too long we want to
-            // have each record on its own line instead of trying to fit as much
-            // as possible in each line. For example:
-            //
-            //    [
-            //       Some("wibble wobble"),
-            //       None,
-            //       Some("wobble wibble"),
-            //    ]
-            //
-            Some(el) if !el.is_simple() => break_(",", ", "),
-            // For simple constants(String, Int, Float), if we have to break the list we still try to
-            // fit as much as possible into a single line instead of putting
-            // each item on its own separate line. For example:
-            //
-            //   [
-            //     1, 2, 3, 4,
-            //     5, 6, 7,
-            //   ]
-            //
-            Some(_) | None => flex_break(",", ", "),
+        let list_packing =
+            self.list_items_packing(elements, None, |element| element.is_simple(), *location);
+        let comma = match list_packing {
+            ListItemsPacking::FitMultiplePerLine => flex_break(",", ", "),
+            ListItemsPacking::FitOnePerLine | ListItemsPacking::BreakOnePerLine => {
+                break_(",", ", ")
+            }
         };
 
         let elements = join(
···
         // of moving those out of the list.
         // Otherwise those would be moved out of the list.
         let comments = self.pop_comments(location.end);
-        match printed_comments(comments, false) {
-            None => doc.append(break_(",", "")).append("]").group(),
+        let doc = match printed_comments(comments, false) {
+            None => doc.append(break_(",", "")).append("]"),
             Some(comment) => doc
                 .append(break_(",", "").nest(INDENT))
                 // ^ See how here we're adding the missing indentation to the
···
                 .append(line())
                 .append("]")
                 .force_break(),
+        };
+
+        match list_packing {
+            ListItemsPacking::FitOnePerLine | ListItemsPacking::FitMultiplePerLine => doc.group(),
+            ListItemsPacking::BreakOnePerLine => doc.force_break(),
         }
     }
 
···
             .is_ok()
     }
 
+    /// Returns true if there's a trailing comma between `start` and `end`.
+    ///
+    fn has_trailing_comma(&self, start: u32, end: u32) -> bool {
+        dbg!(self.trailing_commas)
+            .binary_search_by(|comma| {
+                if *comma < start {
+                    Ordering::Less
+                } else if *comma > end {
+                    Ordering::Greater
+                } else {
+                    Ordering::Equal
+                }
+            })
+            .is_ok()
+    }
+
     fn pipeline<'a>(
         &mut self,
         expressions: &'a Vec1<UntypedExpr>,
···
             };
         }
 
-        let comma = if tail.is_none() && elements.iter().all(UntypedExpr::is_simple_constant) {
-            flex_break(",", ", ")
-        } else {
-            break_(",", ", ")
+        let list_packing =
+            self.list_items_packing(elements, tail, UntypedExpr::is_simple_constant, *location);
+
+        let comma = match list_packing {
+            ListItemsPacking::FitMultiplePerLine => flex_break(",", ", "),
+            ListItemsPacking::FitOnePerLine | ListItemsPacking::BreakOnePerLine => {
+                break_(",", ", ")
+            }
         };
 
         let list_size = elements.len()
···
         // of moving those out of the list.
         // Otherwise those would be moved out of the list.
         let comments = self.pop_comments(location.end);
-        match printed_comments(comments, false) {
-            None => doc.append(last_break).append("]").group(),
+        let doc = match printed_comments(comments, false) {
+            None => doc.append(last_break).append("]"),
             Some(comment) => doc
                 .append(last_break.nest(INDENT))
                 // ^ See how here we're adding the missing indentation to the
···
                 .append(line())
                 .append("]")
                 .force_break(),
+        };
+
+        match list_packing {
+            ListItemsPacking::FitOnePerLine | ListItemsPacking::FitMultiplePerLine => doc.group(),
+            ListItemsPacking::BreakOnePerLine => doc.force_break(),
         }
     }
 
+    fn list_items_packing<'a, T: HasLocation>(
+        &self,
+        items: &'a [T],
+        tail: Option<&'a T>,
+        is_simple_constant: impl Fn(&'a T) -> bool,
+        list_location: SrcSpan,
+    ) -> ListItemsPacking {
+        let ends_with_trailing_comma = tail
+            .map(|tail| tail.location().end)
+            .or_else(|| items.last().map(|last| last.location().end))
+            .is_some_and(|last_element_end| {
+                self.has_trailing_comma(last_element_end, list_location.end)
+            });
+
+        let is_simple_constant_list = tail.is_none() && items.iter().all(is_simple_constant);
+        let has_multiple_elements_per_line =
+            self.has_items_on_the_same_line(items.iter().chain(tail));
+
+        if !ends_with_trailing_comma {
+            // If the list doesn't end with a trailing comma we try and pack it in
+            // a single line; if we can't we'll put one item per line, no matter
+            // the content of the list.
+            ListItemsPacking::FitOnePerLine
+        } else if is_simple_constant_list
+            && has_multiple_elements_per_line
+            && self.spans_multiple_lines(list_location.start, list_location.end)
+        {
+            // If there's a trailing comma, the list is only made of simple
+            // constants and there's already multiple items per line, we try
+            // and pack as many items as possible on each line.
+            ListItemsPacking::FitMultiplePerLine
+        } else {
+            // If it ends with a trailing comma we will force the list on
+            // multiple lines, with one item per line.
+            ListItemsPacking::BreakOnePerLine
+        }
+    }
+
+    fn has_items_on_the_same_line<'a, L: HasLocation + 'a, T: Iterator<Item = &'a L>>(
+        &self,
+        items: T,
+    ) -> bool {
+        let mut previous: Option<SrcSpan> = None;
+        for item in items {
+            let item_location = item.location();
+            // A list has multiple items on the same line if two consecutive
+            // ones do not span multiple lines.
+            if let Some(previous) = previous {
+                if !self.spans_multiple_lines(previous.end, item_location.start) {
+                    return true;
+                }
+            }
+            previous = Some(item_location);
+        }
+        false
+    }
+
     /// Pretty prints an expression to be used in a comma separated list; for
     /// example as a list item, a tuple item or as an argument of a function call.
     fn comma_separated_item<'a>(
···
         }
         .to_doc()
     }
+}
+
+enum ListItemsPacking {
+    /// Try and fit everything on a single line; if the items don't fit, break
+    /// the list putting each item into its own line.
+    ///
+    /// ```gleam
+    /// // unbroken
+    /// [1, 2, 3]
+    ///
+    /// // broken
+    /// [
+    ///   1,
+    ///   2,
+    ///   3,
+    /// ]
+    /// ```
+    ///
+    FitOnePerLine,
+
+    /// Try and fit everything on a single line; if the items don't fit, break
+    /// the list putting as many items as possible in a single line.
+    ///
+    /// ```gleam
+    /// // unbroken
+    /// [1, 2, 3]
+    ///
+    /// // broken
+    /// [
+    ///   1, 2, 3, ...
+    ///   4, 100,
+    /// ]
+    /// ```
+    ///
+    FitMultiplePerLine,
+
+    /// Always break the list, putting each item into its own line:
+    ///
+    /// ```gleam
+    /// [
+    ///   1,
+    ///   2,
+    ///   3,
+    /// ]
+    /// ```
+    BreakOnePerLine,
 }
 
 pub fn break_block(doc: Document<'_>) -> Document<'_> {

compiler-core/src/format/tests.rs

···
         r#"const x = "some long string 1"
   <> "some long string 2"
   <> [
-    "here is a list", "with several elements",
+    "here is a list",
+    "with several elements",
     "in order to make it be too long to fit on one line",
-    "so we can see how it breaks", "onto multiple lines",
+    "so we can see how it breaks",
+    "onto multiple lines",
   ]
   <> "and a last string"
 "#,