Fluent API Formatting is Inconsistent

[Sahasrara]

Environments

• IDE Version:
  Version: 1.98.2 (user setup)
  Commit: ddc367ed5c8936efe395cffeec279b04ffd7db78
  Date: 2025-03-12T13:32:45.399Z
  Electron: 34.2.0
  ElectronBuildId: 11161602
  Chromium: 132.0.6834.196
  Node.js: 20.18.2
  V8: 13.2.152.36-electron.0
  OS: Windows_NT x64 10.0.26100

• Extension Version:
  2.0.6

• CSharpier Version:
  I'm... not sure. It doesn't say in VS Code.

• Operating System:
  Windows 11

• .csharpierrc Settings:
  N/A

• .editorconfig Settings:
  N/A

Log Output
N/A

Steps to reproduce
Format code

Expected behavior
I would expect consistent fluent API formatting, or no fluent api formatting.

Actual behavior
Here's an example chunk of code:

            Singletons<HotelBagatelleActions>
                .Value
                .Golf
                .GP_LeftStick
                .performed += OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled += OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed += OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled += OnLeftStick;

This is how CSharpier formatted the code. I would expect them all to be like the first line, or the first line to be like the following three lines. Instead, it's inconsistently formatted.

[belav]

If I paste your code as provided into the playground none of the lines break.

I can modify them to the point that they break, but then they break as shown. The inconsistency below is due to the varying line lengths.

There is an issue somewhere around automatically breaking invocations of a given length, which this example may fall under, but otherwise I'm not seeing any problem with CSharpier.

// Input
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>.Value.Golf.GP_LeftStick.performed += OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled += OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed += OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled += OnLeftStick;

// Output
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>
    .Value
    .Golf
    .GP_LeftStick
    .performed += OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled +=
    OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>
    .Value
    .Golf
    .GP_RightStick
    .performed += OnLeftStick;
Singletonssssssssssssssssssssssssssssssss<HotelBagatelleActions>
    .Value
    .Golf
    .GP_RightStick
    .canceled += OnLeftStick;

[Sahasrara]

Is there some way for me to assist you in reproducing the issue? I see it consistently on my Visual Studio Code installation. Or do you mean this is a known issue?

[belav]

If you provide the full source file, or provide a code sample that reproduces the issue when you use http://playground.csharpier.com then I can verify what you are seeing.

[Sahasrara]

Sure thing! This code reproduces the issue in that playground:

using System;
using System.Threading;
using Animancer.FSM;
using Cysharp.Threading.Tasks;
using UnityEngine;
using static UnityEngine.InputSystem.InputAction;

namespace HotelBagatelle.Common
{
    public class DolfInput : MonoBehaviour, ILevelManagerListener
    {
        #region Inspector
        [SerializeField]
        DolfInputStateBehaviour[] states;

        [SerializeField]
        DolfInputSharedData sharedData;
        #endregion

        #region State
        StateMachine<DolfInputStateBehaviour> _stateMachine;
        #endregion

        #region Level Events
        public async UniTask OnLevelLoaded(CancellationToken _)
        {
            // Set Dolf Position
            sharedData.LastDolfPosition = sharedData.DolfBall.BallPhysics.Position;

            // Create Trajectory Point List
            sharedData.TrajectoryPoints = new();

            // Enable
            Singletons<HotelBagatelleActions>.Value.Golf.Enable();

            // Setup States
            foreach (DolfInputStateBehaviour state in states)
                state.Setup(sharedData);

            // Set Initial State
            SetState(DolfInputState.KeyboardAndMouse);

            // Subscribe to Gamepad
            Singletons<HotelBagatelleActions>
                .Value
                .Golf
                .GP_LeftStick
                .performed += OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled += OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftShoulder.performed += OnLeftShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftShoulder.canceled += OnLeftShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftTrigger.performed += OnLeftTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftTrigger.canceled += OnLeftTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed += OnRightStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled += OnRightStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightShoulder.performed += OnRightShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightShoulder.canceled += OnRightShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightTrigger.performed += OnRightTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightTrigger.canceled += OnRightTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadUp.performed += OnDPadUp;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadUp.canceled += OnDPadUp;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadDown.performed += OnDPadDown;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadDown.canceled += OnDPadDown;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadLeft.performed += OnDPadLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadLeft.canceled += OnDPadLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadRight.performed += OnDPadRight;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadRight.canceled += OnDPadRight;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_ButtonSouth.performed += OnButtonSouth;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_ButtonSouth.canceled += OnButtonSouth;

            // Subscribe to Pause
            Singletons<EventManager>.Value.onPauseChanged.Unsubscribe(OnPauseChanged);

            // Subscribe to Keyboard and Mouse
            Singletons<HotelBagatelleActions>
                .Value
                .Golf
                .KBM_Left
                .performed += OnKBMLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Left.canceled += OnKBMLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Right.performed += OnKBMRight;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Right.canceled += OnKBMRight;
            Singletons<EventManager>.Value.onDragging.Subscribe(OnKBMDragging);
            Singletons<EventManager>.Value.onDragEnded.Subscribe(OnKBMDragEnded);

            await UniTask.CompletedTask;
        }

        public async UniTask OnLevelUnloading()
        {
            // Unsubscribe from Gamepad
            Singletons<HotelBagatelleActions>
                .Value
                .Golf
                .GP_LeftStick
                .performed -= OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled -= OnLeftStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftShoulder.performed -= OnLeftShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftShoulder.canceled -= OnLeftShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftTrigger.performed -= OnLeftTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftTrigger.canceled -= OnLeftTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed -= OnRightStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled -= OnRightStick;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightShoulder.performed -= OnRightShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightShoulder.canceled -= OnRightShoulder;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightTrigger.performed -= OnRightTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_RightTrigger.canceled -= OnRightTrigger;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadUp.performed -= OnDPadUp;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadUp.canceled -= OnDPadUp;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadDown.performed -= OnDPadDown;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadDown.canceled -= OnDPadDown;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadLeft.performed -= OnDPadLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadLeft.canceled -= OnDPadLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadRight.performed -= OnDPadRight;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_DPadRight.canceled -= OnDPadRight;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_ButtonSouth.performed -= OnButtonSouth;
            Singletons<HotelBagatelleActions>.Value.Golf.GP_ButtonSouth.canceled -= OnButtonSouth;

            // Unsubscribe from Pause
            Singletons<EventManager>.Value.onPauseChanged.Unsubscribe(OnPauseChanged);

            // Unsubscribe from Keyboard and Mouse
            Singletons<HotelBagatelleActions>
                .Value
                .Golf
                .KBM_Left
                .performed -= OnKBMLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Left.canceled -= OnKBMLeft;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Right.performed -= OnKBMRight;
            Singletons<HotelBagatelleActions>.Value.Golf.KBM_Right.canceled -= OnKBMRight;
            Singletons<EventManager>.Value.onDragging.Unsubscribe(OnKBMDragging);
            Singletons<EventManager>.Value.onDragEnded.Unsubscribe(OnKBMDragEnded);

            // Teardown States
            foreach (DolfInputStateBehaviour state in states)
                state.Teardown();

            // Disable
            Singletons<HotelBagatelleActions>.Value.Golf.Disable();

            await UniTask.CompletedTask;
        }
        #endregion

        #region Unity Lifecycle
        void Update()
        {
            // Record Last Dolf Position
            sharedData.LastDolfPosition = sharedData.DolfBall.BallPhysics.Position;
        }
        #endregion

        #region Input Events
        void OnLeftStick(CallbackContext callbackContext)
        {
            sharedData.LeftStick = callbackContext.ReadValue<Vector2>();
            _stateMachine.CurrentState.OnLeftStickChanged();
        }

        void OnLeftShoulder(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.LeftShoulder = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.LeftShoulder = false;
            }
            _stateMachine.CurrentState.OnLeftShoulderChanged();
        }

        void OnLeftTrigger(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.LeftTrigger = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.LeftTrigger = false;
            }
            _stateMachine.CurrentState.OnLeftTriggerChanged();
        }

        void OnRightStick(CallbackContext callbackContext)
        {
            sharedData.RightStick = callbackContext.ReadValue<Vector2>();
            _stateMachine.CurrentState.OnRightStickChanged();
        }

        void OnRightShoulder(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.RightShoulder = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.RightShoulder = false;
            }
            _stateMachine.CurrentState.OnRightShoulderChanged();
        }

        void OnRightTrigger(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.RightTrigger = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.RightTrigger = false;
            }
            _stateMachine.CurrentState.OnRightTriggerChanged();
        }

        void OnDPadUp(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.DPadUp = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.DPadUp = false;
            }
            _stateMachine.CurrentState.OnDPadUpChanged();
        }

        void OnDPadDown(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.DPadDown = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.DPadDown = false;
            }
            _stateMachine.CurrentState.OnDPadDownChanged();
        }

        void OnDPadLeft(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.DPadLeft = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.DPadLeft = false;
            }
            _stateMachine.CurrentState.OnDPadLeftChanged();
        }

        void OnDPadRight(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.DPadRight = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.DPadRight = false;
            }
            _stateMachine.CurrentState.OnDPadRightChanged();
        }

        void OnButtonSouth(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.ButtonSouth = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.ButtonSouth = false;
            }
            _stateMachine.CurrentState.OnButtonSouthChanged();
        }

        void OnPauseChanged()
        {
            sharedData.ControlPaused = Singletons<PlayerControlPauser>.Value.IsPaused();
            _stateMachine.CurrentState.OnPauseChanged();
        }

        void OnKBMLeft(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.KBMLeft = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.KBMLeft = false;
            }
            _stateMachine.CurrentState.OnKBMLeftChanged();
        }

        void OnKBMRight(CallbackContext callbackContext)
        {
            if (callbackContext.action.WasPressedThisFrame())
            {
                sharedData.KBMRight = true;
            }
            if (callbackContext.action.WasReleasedThisFrame())
            {
                sharedData.KBMRight = false;
            }
            _stateMachine.CurrentState.OnKBMRightChanged();
        }

        void OnKBMDragging(DragData dragData)
        {
            sharedData.KBMDragData = dragData;
            _stateMachine.CurrentState.OnKBMDragging();
        }

        void OnKBMDragEnded(DragData dragData)
        {
            sharedData.KBMDragData = null;
            _stateMachine.CurrentState.OnKBMDragEnded();
        }
        #endregion

        #region Public API
        public void SetState(DolfInputState state)
        {
            DolfInputStateBehaviour stateBehaviour = states[(int)state];
            if (_stateMachine == null)
                _stateMachine = new(stateBehaviour);
            else
                _stateMachine.TrySetState(stateBehaviour);
        }
        #endregion

        #region Editor
#if UNITY_EDITOR
        void OnValidate()
        {
            // Order States
            int stateCount = Enum.GetValues(typeof(DolfInputState)).Length;
            if (states != null && states.Length != stateCount)
            {
                states = GetComponents<DolfInputStateBehaviour>();
                Array.Sort(
                    states,
                    (o0, o1) =>
                    {
                        if (!o0 && !o1)
                            return 0;

                        if (!o0)
                            return 1;

                        if (!o1)
                            return -1;

                        int type0 = (int)o0.StateEnum;
                        int type1 = (int)o1.StateEnum;

                        return type0.CompareTo(type1);
                    }
                );
            }
        }
#endif
        #endregion
    }
}

[belav]

It appears that a comment on an invocation chain causes it to break before it should.

Input

// comment
Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.performed += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled += OnLeftStick;

Output

// comment
Singletons<HotelBagatelleActions>
    .Value
    .Golf
    .GP_LeftStick
    .performed += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_LeftStick.canceled += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.performed += OnLeftStick;
Singletons<HotelBagatelleActions>.Value.Golf.GP_RightStick.canceled += OnLeftStick;

[belav]

And thanks for providing the full source so I could figure out the problem!

[Sahasrara]

@belav I think this was released recently, but I'm still seeing the same issue in VSCode. Is there anything I need to do to get the latest changes?

I tried installing via command line:

dotnet new tool-manifest
dotnet tool install csharpier

And also tried uninstalling/reinstalling the extension. I think I might be missing something.