fmt: support nicer single expression clauses

crates/squawk_fmt/tests/after/alter_policy.snap

@@ -17,11 +17,10 @@ alter /* policy */ policy /* name */ account_access_policy
 alter policy account_access_policy
   on public.accounts
   using (
-    account_identifier
-      = a_very_long_session_account_identifier_function(
-        current_user,
-        current_role
-      )
+    account_identifier = a_very_long_session_account_identifier_function(
+      current_user,
+      current_role
+    )
   );
 
 alter policy account_access_policy

crates/squawk_fmt/tests/after/alter_table.snap

@@ -162,3 +162,10 @@ alter /* table */ table /* relation */ options_test
     /* set */ set /* left paren */ (
       /* option */ json /* equals */ = /* value */ constraint /* right paren */
     ) /* semicolon */;
+
+-- parenthesized default expressions are only indented once
+alter table t
+  add column a int
+    default (
+      1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16
+    );

crates/squawk_fmt/tests/after/create_domain.snap

@@ -27,3 +27,10 @@ create /* before domain */ domain /* before name */ public.commented_domain
 
 create domain d text null collate "C";
 create domain d text default 5 collate "C" not null;
+
+-- parenthesized default expressions are only indented once
+create domain d
+  as int
+  default (
+    1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16
+  );

crates/squawk_fmt/tests/after/create_table.snap

@@ -165,3 +165,35 @@ create table t (
   -- end inner
 ); -- trailing end
 -- after
+
+-- parenthesized default expressions are only indented once
+create table t (
+  a int default (
+    1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16
+  )
+);
+
+-- comments in parenthesized default expressions
+create table default_expression_comments (
+  a int /* before default */ default /* before open */ (
+    /* before expression */ greatest(
+      /* before first */ 1 /* before comma */,
+      /* before second */ 2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16 /* before call close */
+    ) /* before default close */
+  ) /* before comma */,
+  b int
+);

crates/squawk_fmt/tests/after/from.snap

@@ -36,8 +36,7 @@ select * from collation for (foo) as collation_name;
 select *
 from /* before lateral */ lateral /* before cast */ cast /* before opening paren */(
   /* before expression */ value
-  /* before as */ as
-  /* before type */ int8 /* before closing paren */
+  /* before as */ as /* before type */ int8 /* before closing paren */
 ) /* before alias */ as /* before alias name */ converted;
 select * from (select 1) as selected;
 select *

crates/squawk_fmt/tests/after/insert.snap

@@ -90,5 +90,6 @@ values (
   1, -- values
   2
 )
-returning a, -- returning
+returning
+  a, -- returning
   b;

crates/squawk_fmt/tests/after/merge.snap

@@ -82,4 +82,5 @@ merge /* before into */ into /* before target */ only /* before target open */(/
   )
 /* before fifth when */ when not matched then
   insert /* before default */ default /* before default values */ values
-/* before returning */ returning /* before return target */ t.id /* before semicolon */;
+/* before returning */ returning
+  /* before return target */ t.id /* before semicolon */;

crates/squawk_fmt/tests/after/select_clauses.snap

@@ -92,3 +92,141 @@ select
 order by
   a, -- order by
   b;
+
+select
+  1
+order by (
+  select count(*)
+  from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap
+);
+
+select
+  1
+order /* before by */ by /* before expression */ (
+  /* before select */ select count(*)
+  from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap /* before close */
+) /* before semicolon */;
+
+select
+  category,
+  current_price > (
+    select avg(current_price)
+    from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap
+  ) as above_average,
+  count(*) filter (
+    where current_price > (
+      select avg(current_price)
+      from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap
+    )
+  ) as expensive_count
+from item i
+  join category_prices p on i.current_price > (
+    select avg(current_price)
+    from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap
+  )
+where current_price > (
+  select avg(current_price)
+  from item
+  where category = i.category or color = i.color
+)
+group by category
+having count(*) > (
+  select count(*)
+  from a_very_long_relation_name_that_forces_the_parenthesized_subquery_to_wrap
+)
+order by count;
+
+select 1
+from t
+where current_price = any(
+  select 10000000000000000000000000000000000000000000000000
+);
+
+select 1
+from t
+where current_price = any(
+  select 1 -- foo
+);
+
+select *
+from item
+where exists(
+  select current_price
+  from a_very_long_relation_name_abcdefghijklmn
+);
+
+select *
+from item
+where my_predicate_function(
+  aaaaaaaaaaaaaaaaaaaaaaaaaa,
+  bbbbbbbbbbbbbbbbbbbbbbbbb
+);
+
+select *
+from item
+where cast(
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa as boolean
+);
+
+select *
+from item
+where /* before predicate */ exists(
+  /* before subquery */ select current_price
+  from a_very_long_relation_name_abcdefghijklmn /* before close */
+);
+
+select *
+from item
+where -- before predicate
+  exists(select current_price from a_very_long_relation_name_abcdefghijklmn);
+
+select 1
+from t
+where a = array[
+  a_very_long_first_array_expression,
+  a_very_long_second_array_expression,
+  a_very_long_third_array_expressiona_very_long_second_array_expression
+];
+
+select *
+from item
+where
+  aaaaaaaaaaaaaaaaaaaaaaaaaa = 1
+  and my_predicate_function(bbbbbbbbbbbbbbbbbbbbbbbbb);
+
+select *
+from t
+order by -- before sort expression
+  f(a);
+
+select *
+from t
+order by -- before sort expression
+  a desc;
+
+select *
+from t
+order by
+  a_very_long_sort_expression_name_that_does_not_fit_on_a_single_line_abcdef;
+
+select *
+from a
+  join b on -- before condition
+    a.id = f(b.id);
+
+select *
+from a
+  join b on -- before condition
+    a.id = b.id;
+
+select *
+from a
+  join b on
+    -- own line
+    a.id = b.id;
+
+select *
+from t
+where
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    = calculate_something();

crates/squawk_fmt/tests/after/select_comments.snap

@@ -77,10 +77,9 @@ select (
   1 -- final paren item
 );
 
-select
-  (
-    1, 2 -- final tuple item
-  );
+select (
+  1, 2 -- final tuple item
+);
 
 select array[
   1 -- final array item

crates/squawk_fmt/tests/after/select_expr.snap

@@ -140,6 +140,9 @@ select
       /* before expr */ array[4] /* before closing paren */
     ) /* after any */,
   exists(select 1 from things),
+  exists(
+    select 10000000000000000000000000000000000000000000000000000000000000000
+  ),
   exists((select 1)),
   exists(table things),
   5 = any(values (1), (5)),
@@ -158,8 +161,7 @@ select
     from a_very_long_exists_relation_name
   ),
   /* before exists */ exists /* before opening paren */(
-    /* before select */ select
-      1 /* before closing paren */
+    /* before select */ select 1 /* before closing paren */
   ) /* after exists */,
   collation for (b + c),
   collation for (
@@ -657,13 +659,11 @@ select
   int8 '1',
   cast(
     a_very_long_cast_input_expression
-    as
-    a_very_long_type_schema_name.a_very_long_cast_type_name
+    as a_very_long_type_schema_name.a_very_long_cast_type_name
   ),
   treat(
     a_very_long_treat_input_expression
-    as
-    a_very_long_type_schema_name.a_very_long_treat_type_name
+    as a_very_long_type_schema_name.a_very_long_treat_type_name
   ),
   a_very_long_postgres_cast_input_expression::a_very_long_type_schema_name.a_very_long_postgres_cast_type_name,
   a_very_long_type_schema_name.a_very_long_type_literal_type_name 'a very long type literal input value',
@@ -870,17 +870,15 @@ select array[
   1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 ];
 
-select
-  (
-    1, -- tuple expr
-    2
-  );
+select (
+  1, -- tuple expr
+  2
+);
 
-select
-  row(
-    1, -- row expr
-    2
-  );
+select row(
+  1, -- row expr
+  2
+);
 
 select array[
   1, -- array expr
@@ -891,3 +889,8 @@ select count(
   a, -- call args
   b
 );
+
+select cast(
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+  as numeric(10, 2)
+);

crates/squawk_fmt/tests/after/types.snap

@@ -165,13 +165,11 @@ select
   ),
   cast(
     a_very_long_expression_name_long_long_long_long_long_long
-    as
-    character varying(12345)
+    as character varying(12345)
   ),
   treat(
     a_very_long_expression_name
-    as
-    a_very_long_type_schema_name.a_very_long_type_name
+    as a_very_long_type_schema_name.a_very_long_type_name
   ),
   a_very_long_type_schema_name.a_very_long_type_name(12345) 'a very long typed string literal value',
   interval 'a very long interval literal value' day to second(12345);