[clang-format] Update GoogleStyle for C# code to match Google's internal C# style guide

[jbcoe]

Summary

Google's C# style guide is at https://google.github.io/styleguide/csharp-style.html

[jbcoe]

I expect that accepting this patch will need require an update to be made to https://github.com/google/styleguide.

[krasimir]

In D79715#2029390, @jbcoe wrote:

I expect that accepting this patch will need require an update to be made to https://github.com/google/styleguide.

I agree; it would be useful to leave a comment somewhere in this code with a link to a Google C# style guide reference.

[MyDeveloperDay]

Assuming you either work for google and understand their style or are qualified to say this is their style then this LGTM

What I couldn't see from the link was where the google C# style guide was?

[jbcoe]

I will get the Google Style guide uploaded and update this patch with a link.

clang/lib/Format/Format.cpp

 //===--- Format.cpp - Format C++ code -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements functions declared in Format.h. This will be
 /// split into separate files as we go.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/Format/Format.h"
 #include "AffectedRangeManager.h"
+#include "BreakableToken.h"
 #include "ContinuationIndenter.h"
 #include "FormatInternal.h"
 #include "FormatTokenLexer.h"
 #include "NamespaceEndCommentsFixer.h"
 #include "SortJavaScriptImports.h"
 #include "TokenAnalyzer.h"
 #include "TokenAnnotator.h"
 #include "UnwrappedLineFormatter.h"
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   } else if (Language == FormatStyle::LK_ObjC) {
     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
     GoogleStyle.ColumnLimit = 100;
     // "Regroup" doesn't work well for ObjC yet (main header heuristic,
     // relationship between ObjC standard library headers and other heades,
     // #imports, etc.)
     GoogleStyle.IncludeStyle.IncludeBlocks =
         tooling::IncludeStyle::IBS_Preserve;
+  } else if (Language == FormatStyle::LK_CSharp) {
+    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
+    GoogleStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
+    GoogleStyle.BreakStringLiterals = false;
+    GoogleStyle.ColumnLimit = 100;
+    GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
   }
 
   return GoogleStyle;
 }
 
 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
   FormatStyle ChromiumStyle = getGoogleStyle(Language);
 

clang/unittests/Format/FormatTestCSharp.cpp

 };)",
                Style);
 }
 
 TEST_F(FormatTestCSharp, CSharpNamedArguments) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
 
   verifyFormat(R"(//
-PrintOrderDetails(orderNum: 31, productName: "Red Mug",
-                  sellerName: "Gift Shop");)",
+PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName: "Gift Shop");)",
                Style);
 
   // Ensure that trailing comments do not cause problems.
   verifyFormat(R"(//
 PrintOrderDetails(orderNum: 31, productName: "Red Mug",  // comment
                   sellerName: "Gift Shop");)",
                Style);
 
public class SaleItem {
 
   verifyFormat(R"(
 // Properties with backing fields
 class TimePeriod {
   public double Hours {
     get { return _seconds / 3600; }
     set {
       if (value < 0 || value > 24)
-        throw new ArgumentOutOfRangeException(
-            $"{nameof(value)} must be between 0 and 24.");
+        throw new ArgumentOutOfRangeException($"{nameof(value)} must be between 0 and 24.");
       _seconds = value * 3600;
     }
   }
 })",
                Style);
 
   verifyFormat(R"(
 // Auto-implemented properties

 }
 
 TEST_F(FormatTestCSharp, CSharpNullableTypes) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
   Style.SpacesInSquareBrackets = false;
 
   verifyFormat(R"(//
 public class A {
-  void foo() { int? value = some.bar(); }
+  void foo() {
+    int? value = some.bar();
+  }
 })",
                Style); // int? is nullable not a conditional expression.
 
   verifyFormat(R"(void foo(int? x, int? y, int? z) {})",
                Style); // Nullables in function definitions.
 
   verifyFormat(R"(public float? Value;)", Style); // no space before `?`.
 
class ItemFactory<T>
     where T : new() {})",
                Style);
 
   verifyFormat(R"(//
 class Dictionary<TKey, TVal>
     where TKey : IComparable<TKey>
     where TVal : IMyInterface {
   public void MyMethod<T>(T t)
-      where T : IMyInterface { doThing(); }
+      where T : IMyInterface {
+    doThing();
+  }
 })",
                Style);
 
   verifyFormat(R"(//
 class ItemFactory<T>
-    where T : new(),
-              IAnInterface<T>,
-              IAnotherInterface<T>,
-              IAnotherInterfaceStill<T> {})",
+    where T : new(), IAnInterface<T>, IAnotherInterface<T>, IAnotherInterfaceStill<T> {})",
                Style);
 
   Style.ColumnLimit = 50; // Force lines to be wrapped.
   verifyFormat(R"(//
 class ItemFactory<T, U>
     where T : new(),
               IAnInterface<T>,
               IAnotherInterface<T, U>,