[Parser] Support alternative operator token keyword args in Objective-C++

[erik.pilkington]

Summary

This fixes rdar://30741878

Thanks!
Erik

[rsmith]

One comment, but otherwise the code change looks mechanically correct. Not accepting only because I don't know whether this is the intended language rule for Objective-C++ or not (please get someone else to sign off on that).

clang/lib/Parse/ParseExpr.cpp

278 ↗

(On Diff #159964)

Just check Tok.getIdentifierInfo(). That will be null for a punctuation token and non-null for a token spelled as an identifier. (I don't think you even need the switch, because we already only get here for operators.)

[erik.pilkington]

Remove isBinaryCXXAlternativeOperatorToken, this check can be done using OpToken.getAsIdentifierInfo(). Thanks!

FWIW, I can't imagine this being anything but an oversight, we go out of our way to support these tokens in ParseObjCSelectorPiece, and we already happen to support unary alternative operators, such as [foo not].

[rjmccall]

Assuming you've done enough source-compatibility testing to say with reasonable confidence that this won't break anything, I think this is fine. It's a core goal of Objective-C/C++ to allow the base language as a complete subset if at all possible.

[erik.pilkington]

In D50527#1194660, @rjmccall wrote:

Assuming you've done enough source-compatibility testing to say with reasonable confidence that this won't break anything, I think this is fine. It's a core goal of Objective-C/C++ to allow the base language as a complete subset if at all possible.

I don't really see how this could break source-compatibility, I don't believe there is a way to start a binary operator's RHS with a colon[1] or a r_square, so this change can only affect programs that were previously ill-formed. I'll run some internal builds and report back though, just to be paranoid.

[1] excluding the GNU conditional expr, which is handled because getIdentifierInfo will always return nullptr for '?'.

[erik.pilkington]

The build came back clean!

[erik.pilkington]

Ping!

[rjmccall]

In D50527#1206460, @erik.pilkington wrote:

Ping!

If the build came back clean, then I think our combination of previous sign-offs is good enough. :)

lib/Parse/ParseExpr.cpp

while (1) {
     if (isFoldOperator(NextTokPrec) && Tok.is(tok::ellipsis)) {
       // FIXME: We can't check this via lookahead before we consume the token
       // because that tickles a lexer bug.
       PP.EnterToken(Tok);
       Tok = OpToken;
       return LHS;
     }
 
+    // In Objective-C++, alternative operator tokens can be used as keyword args
+    // in message expressions. Unconsume the token so that it can reinterpreted
+    // as an identifier in ParseObjCMessageExpressionBody. i.e., we support:
+    //   [foo meth:0 and:0];
+    //   [foo not_eq];
+    if (getLangOpts().ObjC1 && getLangOpts().CPlusPlus &&
+        Tok.isOneOf(tok::colon, tok::r_square) &&
+        OpToken.getIdentifierInfo() != nullptr) {
+      PP.EnterToken(Tok);
+      Tok = OpToken;
+      return LHS;
+    }
+
     // Special case handling for the ternary operator.
     ExprResult TernaryMiddle(true);
     if (NextTokPrec == prec::Conditional) {
       if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
         // Parse a braced-init-list here for error recovery purposes.
         SourceLocation BraceLoc = Tok.getLocation();
         TernaryMiddle = ParseBraceInitializer();
         if (!TernaryMiddle.isInvalid()) {

test/Parser/message-expr-alt-op.mm

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface WeirdInterface
+-(void)allOfThem:(int)a
+             and:(int)b
+          and_eq:(int)c
+          bitand:(int)d
+           bitor:(int)e
+           compl:(int)f
+             not:(int)g
+          not_eq:(int)h
+              or:(int)i
+           or_eq:(int)j
+             xor:(int)k
+          xor_eq:(int)l;
+
+-(void)justAnd:(int)x and:(int)y;
+-(void)and;
+-(void)and:(int)x;
+@end
+
+void call_it(WeirdInterface *x) {
+  [x allOfThem:0
+           and:0
+        and_eq:0
+        bitand:0
+         bitor:0
+         compl:0
+           not:0
+        not_eq:0
+            or:0
+         or_eq:0
+           xor:0
+        xor_eq:0];
+
+  [x and];
+  [x and:0];
+  [x &&:0]; // expected-error{{expected expression}};
+  [x justAnd:0 and:1];
+  [x and: 0 ? : 1];
+}