[Sema] Fix decrement availability for built-in types

[jkorous-apple]

Summary

C++ [over.built]p4:

For every pair (T, VQ), where T is an arithmetic type other than bool, and VQ is either volatile or empty, there exist candidate operator functions of the form

  VQ T&      operator--(VQ T&);
  T          operator--(VQ T&, int);

The bool type is in position LastPromotedIntegralType in BuiltinOperatorOverloadBuilder::getArithmeticType::ArithmeticTypes, but addPlusPlusMinusMinusArithmeticOverloads() is expecting it at position 0.

Original patch by Ettore Speziale.

rdar://problem/34255516

[vsapsai]

test/SemaCXX/overloaded-builtin-operators.cpp

95–99 ↗

(On Diff #140107)

Looks like p3 for lr-- is a typo because p3 is about ++ while p4 is about --. It means the existing test didn't catch this bug. Not sure that adding another positive test will reliably prevent a regression in the future. Currently FloatRef is the type to expose the bug because FloatTy is the first type in ArithmeticTypes.

What if we add a negative test? I.e. something that would fail like

cannot decrement value of type 'BoolRef'

Also we can improve testing for p3 and test that BoolRef does support increment.

[jkorous-apple]

Added test for decrement being disabled for bool.
Fixed comment in test (will put into separate NFC commit).

[jkorous-apple]

Spot on with the negative test idea! Should've done that myself. Thanks.

[vsapsai]

Looks good to me.

cfe/trunk/lib/Sema/SemaOverload.cpp

public:
   //   candidate operator functions of the form
   //
   //       VQ T&      operator--(VQ T&);
   //       T          operator--(VQ T&, int);
   void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
     if (!HasArithmeticOrEnumeralCandidateType)
       return;
 
-    for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1);
-         Arith < NumArithmeticTypes; ++Arith) {
+    for (unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
+      const auto TypeOfT = ArithmeticTypes[Arith];
+      if (Op == OO_MinusMinus && TypeOfT == S.Context.BoolTy)
+        continue;
       addPlusPlusMinusMinusStyleOverloads(
-        ArithmeticTypes[Arith],
+        TypeOfT,
         VisibleTypeConversionsQuals.hasVolatile(),
         VisibleTypeConversionsQuals.hasRestrict());
     }
   }
 
   // C++ [over.built]p5:
   //
   //   For every pair (T, VQ), where T is a cv-qualified or

cfe/trunk/test/SemaCXX/overloaded-builtin-operators.cpp

void f(Short s, Long l, Enum1 e1, Enum2 e2, Xpmf pmf) {
   // C++ [over.built]p17
   (void)static_cast<yes&>(islong(s % l));
   (void)static_cast<yes&>(islong(l << s));
   (void)static_cast<no&>(islong(s << l));
   (void)static_cast<yes&>(islong(e1 % l));
   // FIXME: should pass (void)static_cast<no&>(islong(e1 % e2));
 }
 
+struct BoolRef {
+  operator bool&();
+};
+
 struct ShortRef { // expected-note{{candidate function (the implicit copy assignment operator) not viable}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-note@-2 {{candidate function (the implicit move assignment operator) not viable}}
 #endif
   operator short&();
 };
 
 struct LongRef {
   operator volatile long&();
 };
 
+struct FloatRef {
+  operator float&();
+};
+
 struct XpmfRef { // expected-note{{candidate function (the implicit copy assignment operator) not viable}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-note@-2 {{candidate function (the implicit move assignment operator) not viable}}
 #endif
   operator pmf&();
 };
 
 struct E2Ref {
   operator E2&();
 };
 
-void g(ShortRef sr, LongRef lr, E2Ref e2_ref, XpmfRef pmf_ref) {
+void g(BoolRef br, ShortRef sr, LongRef lr, FloatRef fr, E2Ref e2_ref, XpmfRef pmf_ref) {
   // C++ [over.built]p3
   short s1 = sr++;
 
-  // C++ [over.built]p3
+  // C++ [over.built]p4
   long l1 = lr--;
 
+  // C++ [over.built]p4
+  float f1 = fr--;
+
+  // C++ [over.built]p4
+  bool b2 = br--; // expected-error{{cannot decrement value of type 'BoolRef'}}
+
   // C++ [over.built]p18
   short& sr1 = (sr *= lr);
   volatile long& lr1 = (lr *= sr);
 
   // C++ [over.built]p20:
   E2 e2r2;
   e2r2 = e2_ref;