tree 3024bcae87c16b115f430948d049558590609768
parent 6b2b31e55b6a50f4d6ff356b0e085ef2e4345de4
author Bob Nystrom <rnystrom@google.com> 1709067733 -0800
committer GitHub <noreply@github.com> 1709067733 -0800
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJl3k3VCRC1aQ7uu5UhlAAAfv4QAGCBAuxFAypk7qbmSK0JExqb
 +Vzv8Y03XEpVsBRCCHu+srO8kal2giAKriu3KxK6KcAZaG6FWbkRS5P8UcGtMIEk
 uHW3L5CEyGEk2qrtjAGzfXYgg1ZHLHEG6l63hjnvaTmhILNdVxTVyczXFbcp/pg+
 wYCR/fHB3VJy0s9Y/fAKrBQFUKq3mgMzwi7yb7BOBYtVKYL5+WbpEq+EMynMCeL4
 sc2jiFosiK3DXHfLFbupeRPHtMVPUv7pwpqJ14naNgHMX8SxbYBerCahPvy+EMS1
 n42DTMs+1SivtnGJ8Z1QrsGYYWeXu8iFZsKXeJgCvhnnUYshXlu5g4Oko2Tloe7z
 Lt37eQUivYBUh4+3CM6S7V5pfoz5NInNwLWDJCOr9K3Et9EhScTe7feDBHlop8lU
 us9+UKY4jSfwfo1XRzJjWig4uDuMWGgj2GXBwJoaoubT0klDEywG16QtU9l77ZN3
 HBB19hAVEkkkkkGGBJJdPIGOIV+K9nyVZdQ9vKTYeGd++6uPMO6wlB+Kvf374NmL
 KKs3CE1Q+KUi0FzqSJFe3YsaIt2NvFoZOVUsIcaxTIvphhpKC7kKXbtFe/BvytbO
 8R/REs5/n5Y+PyMsdX1Uzc/f9F1VqeUdroBDQc3eORyMfSEBq1kEO5lFtWZaWG3R
 9f2ctsFofm7Wk+hGPWc6
 =Lcht
 -----END PGP SIGNATURE-----
 

Tweak the heuristics on which expressions allow block formatting. (#1408)

Tweak the heuristics on which expressions allow block formatting.

I was trying out the new formatting on Flutter and noticed a few issues:

1. Immediately-invoked functions in asserts are common.

Prior to this change, these were not block format candidates, giving
you:

```dart
assert(
  () {
    // Some slow computation...
  }(),
  'Message.',
);
```

With this change, they're treated like (uninvoked) function expressions:

```dart
assert(() {
  // Some slow computation...
}(), 'Message.');
```

2. Formatting large deep widget trees looks weird.

Prior to this change, a function call inside an argument list can be
treated like a block argument even if there are other arguments. That
tends to pack things in strangely in widget code, like:

```dart
SizedBox(height: 1000.0, width: double.infinity, child: Column(
  children: <Widget>[Scrollbar(key: key1, child: SizedBox(
    height: 300.0,
    width: double.infinity,
    child: SingleChildScrollView(key: innerKey, child: const SizedBox(key: Key(
      'Inner scrollable',
    ), height: 1000.0, width: double.infinity)),
  ))],
));
```

With this change, a function or method call inside an argument list is
only block formatted if there are no other arguments. In other words,
you can block format a function call if the outer call is a pure wrapper
around the call, but not otherwise. That leads to:

```dart
SizedBox(
  height: 1000.0,
  width: double.infinity,
  child: Column(children: <Widget>[Scrollbar(
    key: key1,
    child: SizedBox(
      height: 300.0,
      width: double.infinity,
      child: SingleChildScrollView(
        key: innerKey,
        child: const SizedBox(
          key: Key('Inner scrollable'),
          height: 1000.0,
          width: double.infinity,
        ),
      ),
    ),
  )]),
);
```

I think that looks a lot nicer.

3. Deep, complex argument lists are combinatorially slow.

We have an optimization to eagerly force an argument list to split if
its contents clearly won't fit. But that optimization ignores the size
of a potential block argument since the contents of that can be wrapped
across multiple lines without forcing the outer argument list to split.

A consequence of that is that big deeply nested function calls end up
slow if it happens that each one only has a single block-formattable
call. That turns out to be very common in Flutter code where you have a
deep chain of nested widgets along with a bunch of other arguments.

The above change to disallow block formatting function calls if there
are any other arguments conveniently fixes that performance issue in
most cases. (Though I expect we will want to do more work here to handle
pathological cases.)