Implementing rules for when lines are forced before members

CSharpier.sln.DotSettings

@@ -2,4 +2,5 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Concated/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=csharpierignore/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=csharpierrc/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=externs/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Sharpier/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Src/CSharpier.Playground/ClientApp/src/FormatCode.ts

@@ -3,37 +3,53 @@ let marks: any[] = [];
 let editor: any = undefined;
 
 export const formatCode = async (code: string) => {
-    const response = await fetch("/Format", {
-        method: "POST",
-        body: JSON.stringify(code),
-        headers: {
-            "Content-Type": "application/json",
-            "cache-control": "no-cache",
-        },
-    });
-    if (response.status === 200) {
-        const data = await response.json();
+    const makeRequest = async () => {
+        const response = await fetch("/Format", {
+            method: "POST",
+            body: JSON.stringify(code),
+            headers: {
+                "Content-Type": "application/json",
+                "cache-control": "no-cache",
+            },
+        });
+        if (response.status === 200) {
+            const data = await response.json();
 
-        setTimeout(() => {
-            setupMarks(data.errors);
-        }, 100);
+            setTimeout(() => {
+                setupMarks(data.errors);
+            }, 100);
 
-        return {
-            syntaxTree: JSON.parse(data.json),
-            formattedCode: data.code,
-            doc: data.doc,
-            hasErrors: !!data.errors.length,
-        };
-    } else {
-        const text = await response.text();
-        return {
-            formattedCode: text,
-            doc: text,
-            hasErrors: true,
-        };
+            return {
+                syntaxTree: JSON.parse(data.json),
+                formattedCode: data.code,
+                doc: data.doc,
+                hasErrors: !!data.errors.length,
+            };
+        } else {
+            const text = await response.text();
+            return {
+                formattedCode: text,
+                doc: text,
+                hasErrors: true,
+            };
+        }
+    }
+
+    for (let x = 0; x < 5; x++) {
+        try {
+            return makeRequest();
+        }
+        catch {
+            await sleep(500);
+        }
     }
+    return makeRequest();
 };
 
+function sleep (milliseconds: number) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
 const setupMarks = (errors: any[]) => {
     if (!editor) {
         setTimeout(() => {

Src/CSharpier.Tests/FormattingTests/TestFiles/AttributeLists.cst

@@ -1,10 +1,12 @@
 [assembly: System.Copyright("(C) 2009")]
 [module: System.Copyright("\n\t\u0123(C) \"2009" + "\u0123")]
+
 [Obsolete]
 class ClassName
 {
     [Obsolete]
     private string Field;
+
     [Obsolete]
     public string Property
     {

Src/CSharpier.Tests/FormattingTests/TestFiles/Comments.cst

@@ -84,8 +84,10 @@ public class ClassName
     }
 
     IReadOnlyList<IArgument> ICommand.Arguments => Arguments;
+
     /// <DocumentationCommentDoesNotCauseBreaking />
     IReadOnlyList<IArgument> ICommand.Arguments => Arguments;
+
     // regular comment does not cause breaking
     IReadOnlyList<IArgument> ICommand.Arguments => Arguments;
 }

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitAttributes.cst

@@ -0,0 +1,5 @@
+using System.Diagnostics.CodeAnalysis;
+[assembly: ForceLineAbove]
+[assembly: ButNotHere]
+
+[assembly: ButKeepThisOne]

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitAttributes.expected.cst

@@ -0,0 +1,6 @@
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: ForceLineAbove]
+[assembly: ButNotHere]
+
+[assembly: ButKeepThisOne]

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitIfDirectiveEdgeCase.cst

@@ -0,0 +1,10 @@
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Reflection;
+
+#if KEEP_LINE_ABOVE
+namespace System.Web.Http.Internal
+#else
+namespace System.Web.WebPages
+#endif
+{ }

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitIfDirectiveEdgeCase2.cst

@@ -0,0 +1,12 @@
+#if DONT_ADD_EXTRA_LINES
+using System.Net.Http;
+#else
+using System.Web.Routing;
+#endif
+
+#if DONT_ADD_EXTRA_LINES
+namespace System.Web.Http.Routing.Constraints
+#else
+namespace System.Web.Mvc.Routing.Constraints
+#endif
+{ }

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitIfDirectiveEdgeCase3.cst

@@ -0,0 +1,6 @@
+#if NO_DOUBLE_LINE_WITH_FILE_SCOPED
+using System;
+
+#endif
+
+namespace Namespace;

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitIfDirectiveEdgeCase4.cst

@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+#if NO_EXTRA_LINES_WITH_ATTRIBUTE
+using System.Runtime.CompilerServices;
+#endif
+
+[assembly: Attribute]

Src/CSharpier.Tests/FormattingTests/TestFiles/CompilationUnitIfDirectiveEdgeCase5.cst

@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+#if KEEP_LINE_ABOVE
+[assembly: Attribute]
+#endif
+[assembly: Attribute]

Src/CSharpier.Tests/FormattingTests/TestFiles/Directives_CompilationUnit.cst

@@ -0,0 +1,19 @@
+#if NO_EXTRA_LINES
+extern alias Foo1;
+#else
+extern alias Foo2;
+#endif
+
+#if NO_EXTRA_LINES
+using System.Net.Http;
+#else
+using System.Web.Routing;
+#endif
+
+using System.Web.Http;
+
+#if KEEP_LINE_ABOVE
+using System.Web.Http;
+#endif
+
+namespace Namespace { }

Src/CSharpier.Tests/FormattingTests/TestFiles/Directives_FileScopedNamespace.cst

@@ -0,0 +1,15 @@
+namespace FileScoped;
+
+#if NO_EXTRA_LINES
+extern alias Foo1;
+#else
+extern alias Foo2;
+#endif
+
+#if NO_EXTRA_LINES
+using System.Net.Http;
+#else
+using System.Web.Routing;
+#endif
+
+class ClassName { }

Src/CSharpier.Tests/FormattingTests/TestFiles/Directives_Namespace.cst

@@ -0,0 +1,16 @@
+namespace Namespace
+{
+#if NO_EXTRA_LINES
+    extern alias Foo1;
+#else
+    extern alias Foo2;
+#endif
+
+#if NO_EXTRA_LINES
+    using System.Net.Http;
+#else
+    using System.Web.Routing;
+#endif
+
+    class ClassName { }
+}

Src/CSharpier.Tests/FormattingTests/TestFiles/ExternAliasDirectives.cst

@@ -8,6 +8,7 @@ alias // alias trailing
 Foo;
 
 extern alias Foo;
+
 namespace Namespace
 {
     extern alias Bar;

Src/CSharpier.Tests/FormattingTests/TestFiles/MemberLines.cst

@@ -0,0 +1,136 @@
+public class ClassRules
+{
+    public void NeverLineBeforeFirstMember() { }
+    public void AlwaysLineBetweenMethods() { }
+    public void EvenWithLambdaBody() => "";
+    private enum AlwaysLineBeforeEnum
+    {
+        One,
+        Two
+    }
+
+    private enum NoDoubleLines
+    {
+        One,
+        Two
+    }
+    private class AlwaysLineBeforeClass { }
+
+    private class NoDoubleLines { }
+    private interface IAlwaysLineBeforeInterface { }
+
+    private interface INoDoubleLines { }
+    public ClassRules() { }
+
+    public ClassRules() { }
+    public ~ClassName() { }
+
+    public ~ClassName() { }
+    public static implicit operator ClassRules(string s)
+    {
+        return new Test();
+    }
+
+    public static implicit operator ClassRules(int i)
+    {
+        return new Test();
+    }
+    public record SomeRecord1(string property);
+
+    public record SomeRecord2(string property);
+    public struct SomeStruct1 { }
+
+    public struct SomeStruct2 { }
+    static ClassRules operator +(ClassRules a, ClassRules b)
+    {
+        return a.Add(b);
+    }
+
+    static ClassRules operator -(ClassRules a, ClassRules b)
+    {
+        return a.Subtract(b);
+    }
+
+    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;
+
+    private string PropertiesCanBeGrouped { get; set; }
+    private string BecauseTheyDontForceLines { get; set; }
+    // comments force a line
+    private string PropertyWithComment;
+    [AttributesForceALine]
+    private string PropertyWithAttribute;
+
+    delegate void DelegatesAreLikeFields();
+    delegate void AndCanBeGrouped();
+    // comments force a line
+    delegate void DelegateWithComment();
+    [AttributesForceALine]
+    delegate void DelegateWithAttribute();
+
+    public void AlwaysLineBetweenMethods() { }
+    private string FieldAfterMethodGetsLine;
+
+#if EDGE_CASE_SHOULD_KEEP_LINE_ABOVE_METHOD
+    private string Field;
+#else
+    private string Field;
+#endif
+
+    public void SomeMethod() { }
+
+#pragma warning disable 0618
+    public void KeepLineAboveAndBelow() { }
+#pragma warning restore 0618    
+
+    public void SomeMethod() { }
+}
+public class LineBeforeClass { }
+public interface InterfaceRulesAreLikeClassesButMethodsFollowTheFieldRulesAbove
+{
+    void NeverLineHere();
+
+    void ExistingLineHereIsKept();
+    void ButNoLineIsAdded();
+    // comments do force a line
+    void MethodWithComment();
+}
+
+abstract class AbstractClass
+{
+    abstract void NoLineHere() { }
+
+    abstract void KeepTheLineHere();
+    abstract void DoNotForceTheLineHere();
+    void ButForceLineForRealMethod() { }
+}
+
+public class ClassName
+{
+    private string someField1;
+
+#if KEEP_LINE_ABOVE
+    private string someField2;
+#endif
+
+    private string someField2;
+}
+
+public class ClassName
+{
+#region RegionWithSpaceBeforeAndAfterMethod
+
+    void SomeMethod() { }
+
+#endregion
+
+    void SomeMethod() { }
+}