[clang-format] Correct line breaks in C# generic type constraints

[jbcoe]

Fix failing test by preventing inconsistent states from being constructed where canBreak is false and mustBreak is true.

[krasimir]

Awesome!

clang/lib/Format/TokenAnnotator.cpp

case tok::identifier:
       break;
     default:
       break;
     }
     return true;
   }
 
   void parseCSharpGenericTypeConstraint() {
+    int OpenAngleBracketsCount = 0;
     while (CurrentToken) {
       if (CurrentToken->is(tok::less)) {
         // parseAngle is too greedy and will consume the whole line.
         CurrentToken->Type = TT_TemplateOpener;
+        ++OpenAngleBracketsCount;
         next();
       } else if (CurrentToken->is(tok::greater)) {
         CurrentToken->Type = TT_TemplateCloser;
+        --OpenAngleBracketsCount;
         next();
-      } else if (CurrentToken->is(tok::comma)) {
+      } else if (CurrentToken->is(tok::comma) && OpenAngleBracketsCount==0) {
+        // We allow line breaks after GenericTypeConstraintComma's
+        // so do not flag commas in Generics as GenericTypeConstraintComma's.
         CurrentToken->Type = TT_CSharpGenericTypeConstraintComma;
         next();
       } else if (CurrentToken->is(Keywords.kw_where)) {
         CurrentToken->Type = TT_CSharpGenericTypeConstraint;
         next();
       } else if (CurrentToken->is(tok::colon)) {
         CurrentToken->Type = TT_CSharpGenericTypeConstraintColon;
         next();

clang/lib/Format/UnwrappedLineParser.cpp

void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
   if (FormatTok->isOneOf(tok::colon, tok::less)) {
     while (!eof()) {
       if (FormatTok->is(tok::l_brace)) {
         calculateBraceTypes(/*ExpectClassBody=*/true);
         if (!tryToParseBracedList())
           break;
       }
       if (FormatTok->Tok.is(tok::semi))
-        return;
+        return;  
+      if (Style.isCSharp() && FormatTok->is(Keywords.kw_where)) {
+        addUnwrappedLine();
+        nextToken();
+        parseCSharpGenericTypeConstraint();
+        return;
+      }
       nextToken();
     }
   }
   if (FormatTok->Tok.is(tok::l_brace)) {
     if (ParseAsExpr) {
       parseChildBlock();
     } else {
       if (ShouldBreakBeforeBrace(Style, InitialToken))
         addUnwrappedLine();
 
       parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
                  /*MunchSemi=*/false);
     }
   }
+  // if (Style.isCSharp() && FormatTok->is(Keywords.kw_where)) {
+  //   addUnwrappedLine();
+  //   nextToken();
+  //   parseCSharpGenericTypeConstraint();
+  // }
   // There is no addUnwrappedLine() here so that we fall through to parsing a
   // structural element afterwards. Thus, in "class A {} n, m;",
   // "} n, m;" will end up in one unwrapped line.
 }
 
 void UnwrappedLineParser::parseObjCMethod() {
   assert(FormatTok->Tok.isOneOf(tok::l_paren, tok::identifier) &&
          "'(' or identifier expected.");

clang/unittests/Format/FormatTestCSharp.cpp

 class Dictionary<TKey, TVal>
     where TKey : IComparable<TKey>
     where TVal : IMyInterface {
   public void MyMethod<T>(T t)
       where T : IMyInterface { doThing(); }
 })",
                Style);
 
+  Style.ColumnLimit = 50; // Force lines to be wrapped.
   verifyFormat(R"(//
-class ItemFactory<T>
-    where T : new(),
-              IAnInterface<T>,
-              IAnotherInterface<T>,
-              IAnotherInterfaceStill<T> {})",
+class ItemFactory<T, U>
+    where T : new(), 
+              IAnInterface<T>, 
+              IAnotherInterface<T, U>, 
+              IAnotherInterfaceStill<T, U> {})",
                Style);
 
   // In other languages `where` can be used as a normal identifier.
   // This example is in C++!
   verifyFormat(R"(//
 class A {
   int f(int where) {}
 };)",
                getGoogleStyle(FormatStyle::LK_Cpp));
 }
 
 } // namespace format
 } // end namespace clang