Handle C variables with name that matches c++ access specifier

.arclint

 {
   "linters": {
     "clang-format": {
       "type": "script-and-regex",
-      "script-and-regex.script": "bash utils/arcanist/clang-format.sh",
+      "script-and-regex.script": "cmd utils\\arcanist\\clang-format.sh",
       "script-and-regex.regex": "/^(?P<severity>[[:alpha:]]+)\n(?P<message>[^\n]+)\n(====|(?P<line>\\d),(?P<char>\\d)\n(?P<original>.*)>>>>\n(?P<replacement>.*)<<<<\n)$/s",
       "include": [
         "(\\.(cc|cpp|h)$)"
       ],
       "exclude": [
         "(^clang/test/)"
       ]
     }
   }
 }

clang/lib/Format/FormatToken.h

#define LIST_TOKEN_TYPES                                                       \
   TYPE(CSharpNamedArgumentColon)                                               \
   TYPE(CSharpNullable)                                                         \
   TYPE(CSharpNullConditionalLSquare)                                           \
   TYPE(CSharpGenericTypeConstraint)                                            \
   TYPE(CSharpGenericTypeConstraintColon)                                       \
   TYPE(CSharpGenericTypeConstraintComma)                                       \
   TYPE(Unknown)
 
+static const std::set<clang::tok::TokenKind> CppOperatorsFollowingVar = {
+    tok::l_square,      tok::r_square,
+    tok::l_paren,       tok::r_paren,
+    tok::r_brace,       tok::period,
+    tok::ellipsis,      tok::amp,
+    tok::ampamp,        tok::ampequal,
+    tok::star,          tok::starequal,
+    tok::plus,          tok::plusplus,
+    tok::plusequal,     tok::minus,
+    tok::arrow,         tok::minusminus,
+    tok::minusequal,    tok::exclaim,
+    tok::exclaimequal,  tok::slash,
+    tok::slashequal,    tok::percent,
+    tok::percentequal,  tok::less,
+    tok::lessless,      tok::lessequal,
+    tok::lesslessequal, tok::spaceship,
+    tok::greater,       tok::greatergreater,
+    tok::greaterequal,  tok::greatergreaterequal,
+    tok::caret,         tok::caretequal,
+    tok::pipe,          tok::pipepipe,
+    tok::pipeequal,     tok::question,
+    tok::semi,          tok::equal,
+    tok::equalequal,    tok::comma,
+    tok::hash,          tok::hashhash,
+    tok::hashat};
+
 /// Determines the semantic type of a syntactic token, e.g. whether "<" is a
 /// template opener or binary operator.
 enum TokenType : uint8_t {
 #define TYPE(X) TT_##X,
   LIST_TOKEN_TYPES
 #undef TYPE
       NUM_TOKEN_TYPES
 };

clang/lib/Format/UnwrappedLineFormatter.cpp

private:
   /// Get the offset of the line relatively to the level.
   ///
   /// For example, 'public:' labels in classes are offset by 1 or 2
   /// characters to the left from their level.
   int getIndentOffset(const FormatToken &RootToken) {
     if (Style.Language == FormatStyle::LK_Java || Style.isJavaScript() ||
         Style.isCSharp())
       return 0;
-    if (RootToken.isAccessSpecifier(false) ||
+    if (RootToken.isAccessSpecifier(Style.Language == FormatStyle::LK_Cpp) ||
+        (RootToken.Next &&
+         RootToken.Next->isOneOf(Keywords.kw_slots, Keywords.kw_qslots) &&
+         RootToken.Next->Next && RootToken.Next->Next->is(tok::colon)) ||
+        (RootToken.isAccessSpecifier(false) &&
+         (!RootToken.Next ||
+          CppOperatorsFollowingVar.find(RootToken.Next->Tok.getKind()) ==
+              clang::format::CppOperatorsFollowingVar.end())) ||
         RootToken.isObjCAccessSpecifier() ||
         (RootToken.isOneOf(Keywords.kw_signals, Keywords.kw_qsignals) &&
          RootToken.Next && RootToken.Next->is(tok::colon))) {
       // The AccessModifierOffset may be overridden by IndentAccessModifiers,
       // in which case we take a negative value of the IndentWidth to simulate
       // the upper indent level.
       return Style.IndentAccessModifiers ? -Style.IndentWidth
                                          : Style.AccessModifierOffset;

clang/lib/Format/UnwrappedLineParser.cpp

 }
 
 void UnwrappedLineParser::parseAccessSpecifier() {
   nextToken();
   // Understand Qt's slots.
   if (FormatTok->isOneOf(Keywords.kw_slots, Keywords.kw_qslots))
     nextToken();
   // Otherwise, we don't know what it is, and we'd better keep the next token.
-  if (FormatTok->Tok.is(tok::colon))
+  if (FormatTok->Tok.is(tok::colon)) {
     nextToken();
     addUnwrappedLine();
+    return;
+  }
+  // if followed by an operator probably intended to be a variable, dont treat
+  // as access specifier
+  if (clang::format::OperatorsFollowingVar.find(FormatTok->Tok.getKind()) ==
+      OperatorsFollowingVar.end()) {
+    addUnwrappedLine();
+  }
 }
 
 void UnwrappedLineParser::parseConcept() {
   assert(FormatTok->Tok.is(tok::kw_concept) && "'concept' expected");
   nextToken();
   if (!FormatTok->Tok.is(tok::identifier))
     return;
   nextToken();

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
   verifyFormat("for (Signals signals : f()) {\n}");
   verifyFormat("{\n"
                "  signals.set(); // This needs indentation.\n"
                "}");
   verifyFormat("void f() {\n"
                "label:\n"
                "  signals.baz();\n"
                "}");
+  // Var that looks like accessSpecifier
+  verifyFormat("private.p = 1;");
 }
 
 TEST_F(FormatTest, SeparatesLogicalBlocks) {
   EXPECT_EQ("class A {\n"
             "public:\n"
             "  void f();\n"
             "\n"
             "private:\n"