formatter: improve compact formatting for signatures, calls, logs, and composites

[starius]

Summary

This updates the next formatter to handle the formatting shapes found during downstream adoption: compacting simple nested calls, keeping short return/result groups packed, normalizing awkward partial signature splits, improving printf/error formatting, and making elided composite literal formatting more consistent. The examples below are representative of the behavioral changes rather than a commit-by-commit list.

Compact simple nested single-argument calls

Before:

maxPrepayRoutingFee := getMaxRoutingFee(
	btcutil.Amount(
		quote.PrepayAmtSat,
	),
)

After:

maxPrepayRoutingFee := getMaxRoutingFee(
	btcutil.Amount(quote.PrepayAmtSat),
)

Keep blank lines before final returns

After compacting prior calls, the formatter still keeps the generic blank-line-before-return rule.

Before:

err := finalizedHtlcTx.Deserialize(
	bytes.NewReader(
		row.FinalizedHtlcTx,
	),
)
return err

After:

err := finalizedHtlcTx.Deserialize(
	bytes.NewReader(row.FinalizedHtlcTx),
)

return err

Pack simple multi-result returns

Simple nested calls in return values are packed when they fit.

Before:

return args.Get(0).(chan *chainntnfs.TxConfirmation), args.Get(1).(chan error), args.Error(
	2,
)

After:

return args.Get(0).(chan *chainntnfs.TxConfirmation),
	args.Get(1).(chan error), args.Error(2)

Move single named params only in the already-split result shape

The single named parameter compaction is intentionally narrow: it applies to signatures where arguments are already split and the results start after ) (. It does not use this rule to rewrite already-good shapes such as a multiline parameter with inline results.

Before:

func rpcRouteCancel(
	details *outCancelDetails) (
	*veryLongRouteCancelResponseWithAdditionalSuffix, error) {

	return nil, nil
}

After:

func rpcRouteCancel(details *outCancelDetails) (
	*veryLongRouteCancelResponseWithAdditionalSuffix, error) {

	return nil, nil
}

Normalize partial return-list splits

When a partial return-list split is awkward, the formatter moves the parameter down and packs short results.

Before:

func unmarshalFixedPoint2(fp *looprpc.FixedPoint) (*rfqmath.BigIntFixedPoint,
	error) {

	return nil, nil
}

After:

func unmarshalFixedPoint2(
	fp *looprpc.FixedPoint) (*rfqmath.BigIntFixedPoint, error) {

	return nil, nil
}

Split long printf/error format strings while keeping short arguments attached

Before:

return fmt.Errorf("this is a long error message with a couple (%d) place holders", len(things))

After:

return fmt.Errorf("this is a long error message with a couple (%d) "+
	"place holders", len(things))

Keep nested errorf format strings inline when the nested call fits

Before:

return f.HandleError(
	fmt.Errorf(
		"invalid swap invoice hash: expected %x got %x",
		preimage.Hash(), payReq.Hash,
	),
)

After:

return f.HandleError(
	fmt.Errorf("invalid swap invoice hash: expected %x got %x",
		preimage.Hash(), payReq.Hash),
)

Compact single-element composite literals

This is generic and does not special-case any type name. The lntypes.Hash fixture is just a representative type-shaped example.

Before:

SwapHash: lntypes.Hash{
	1,
},
Marker: sampleMarker{
	"ready",
},

After:

SwapHash: lntypes.Hash{1},
Marker:   sampleMarker{"ready"},

Keep simple elided composite elements packed

Before:

hops := []*RouteHop{
	{},
	{},
	{},
}

After:

hops := []*RouteHop{
	{}, {}, {},
}

Expand keyed elided composite values

Adjacent keyed entries no longer share a line.

Before:

requiredOps := map[string][]PermissionOp{
	"/service/Action": {{
		Entity: "swap",
		Action: "execute",
	}, {
		Entity: "service",
		Action: "read",
	}},
}

After:

requiredOps := map[string][]PermissionOp{
	"/service/Action": {
		{
			Entity: "swap",
			Action: "execute",
		},
		{
			Entity: "service",
			Action: "read",
		},
	},
}

Validation

• make self-check
• make lint