Force lines before and after some members.

[GravlLift]

Csharpier likes getting rid of duplicate lines, but doesn't seem to have an opinion on single line breaks between methods. Both of these examples are unaltered by running csharpier, for example:

public string Foo() 
{
  return "foo";
}

public string Bar() 
{
  return "bar";
}

public string Foo() 
{
  return "foo";
}
public string Bar() 
{
  return "bar";
}

Personally the first one is more appealing to me, but either way, an opinion would be useful.

Are there any plans to implement something like this? I assume there a whole mess of edge cases I'm not considering here.

[respel]

Thanks for the issue, Jason.

The reason we don't do it right now is that it's tricky. CSharpier is heavily inspired by prettier and follows prettier's rationale regarding empty lines.

I agree with you though that we should consider it at some point of time.

Are there any plans to implement something like this?

Not that I know of. This is imo the first issue that we've had regarding this.

[respel]

@belav @shocklateboy92 How do you guys feel about this?

[belav]

It is definitely something we should consider.

I personally like to have a blank line between methods. Unless the methods are expression bodied, then no lines. Usually no lines between properties. But if properties have attributes then I like a line between them. Etc. My point being that if we go down this path, we'd have to decide on the rules for when csharpier should insert a blank line.

The alternative would be to use something else like stylecop to enforce the rules for where blank lines are, and let csharpier format everything around it. There are a number of stylecop rules that conflict with csharpier though, so we need to determine what those are so we can provide people with the list of rules to disable when using csharpier.

I'm not sure that I have a strong opinion on if Csharpier should add empty lines or not. I lean towards no, but that's mostly because I know there is a ton of other work to get done.

[shocklateboy92]

I just read the doc that @respel linked, and I don't think it necessarily applies here. As far as I can tell, it's referring to the fact that prettier no longer removes blank lines (I remember it used to, in their earlier versions). I don't think they have many qualms with adding them. (I swear I've come across examples where they do so).

That being said, I too don't have particularly strong opinions one way or the other. @GravlLift feel free to make a pull request if you do 😄

[belav]

Prettier for ts/js definitely removes blank lines if you have multiples in a row. I'm not sure about if it ever adds them.

The prettier-java plugin does add them in some cases.
This PR is to enforce adding a blank line at the start of classes - jhipster/prettier-java#398
And there is some discussion about other places to add lines, although it doesn't seem to have gone anywhere yet - jhipster/prettier-java#284

The prettier philosophy of adding/removing blank lines may very from plugin to plugin. Maybe the official plugins are more consistent with the philosophy.

[shocklateboy92]

The markdown plugin adds a ton of newlines 🤿

[Kurt-von-Laven]

Black does a really good job of handling (both adding and removing) empty lines in my opinion if someone decides to take this on some day.

[belav]

This is the current set of rules I am considering implementing.

I was considering removing lines between fields and single line properties, but digging through public repos it seems pretty common for people to group fields and properties using a blank line between the groups.

public class ClassRules
{
    public void NeverLineBeforeFirstMember() { }

    public void AlwaysLineBetweenMethods() { }

    public void EvenWithLambdaBody() => "";

    private enum AlwaysLineBeforeEnum
    {
        One,
        Two
    }

    private class AlwaysLineBeforeClass { }

    private interface IAlwaysLineBeforeInterface { }

    // the rest of these also force a line
    // constructor
    // destructor
    // conversion operator
    // record declaration
    // struct declaration
    // operator

    private string FieldsCanBeGroupedBecauseLinesWillBeKept;
    private string ButLinesAreNotForcedHere;

    // comments force a line
    private string FieldWithComment;

    /* comments force a line */
    private string FieldWithComment;

    /// <summary> comments force a line </summary> ///
    private string FieldWithComment;
    
    [AttributesForceALine]
    private string FieldWithAttribute;

    // treat the rest of these the same as fields
    // properties
    // indexers
    // event declarations
    // event fields
    // delegate declarations
}

public interface InterfaceRulesAreLikeClassesButMethodsFollowTheFieldRulesAbove
{
    void NeverLineHere();
    
    void ExistingLineHereIsKept();
    void ButNoLineIsAdded();
    
    // comments do force a line
    void MethodWithComment();
}

// records and structs should be the same as class rules

public enum EnumRules
{
    ALineAboveThisWouldBeRemoved,
    ALineAboveThisWouldBeRemovedAsWell,
    
    // unless there is a comment, then force one,
   LineHere,

   [AttributesAlsoForceLines]
   LineHere,
}