Enable C++2a Chrono Literals

[erichkeane]

Summary

C++2a via http://wg21.link/p0355 permits the library
literals of 'd' and 'y'. This patch enables them in the
Lexer so that they can be properly parsed.

Note that 'd' gets confused with the hex character, so
modifications to how octal, binary, and decimal numbers are
parsed were required. Since this is simply making previously
invalid code legal, this should be fine.

Hex still greedily parses the 'd' as a hexit, since it would
a: violate [lex.ext]p1
b: break existing code.

[mclow.lists]

This looks ok to me - I'm assuming that somewhere there's a test for int foo = 0x123d, so we're sure that didn't get broken.

test/SemaCXX/cxx2a-user-defined-literals.cpp

9

Do you need string here, or is this a copy-pasto?

[erichkeane]

In D49504#1167045, @mclow.lists wrote:

This looks ok to me - I'm assuming that somewhere there's a test for int foo = 0x123d, so we're sure that didn't get broken.

The hex_d SHOULD be testing that, it ensures that the RHS is an integer.

test/SemaCXX/cxx2a-user-defined-literals.cpp

9

Gah, good catch. I was testing something else briefly.

[erichkeane]

@mclow.lists s comments.

[aaron.ballman]

lib/Lex/LiteralSupport.cpp

815

Is it possible for the library to expose those outside of C++2a mode? We pass true for the C++14 cases, so I'm wondering about tying it to C++2a explicitly.

test/SemaCXX/cxx2a-user-defined-literals.cpp

2

Can you drop the svn properties, please?

13

Is this needed?

[erichkeane]

lib/Lex/LiteralSupport.cpp

815

In the C++14 cases, we return true because we've checked C++14 mode on line 805. I was hoping to do that for consistencies sake. Depending on your opinion, bringing 805 down to 812/813/814 (checking inline) might be a good idea.

According to the tests, 'sv' (string view) was the only one for C++17, but it wasn't really necessary to check here since it is only allowed on strings and not on integer literals.

test/SemaCXX/cxx2a-user-defined-literals.cpp

2

Yep, will do :)

13

It is, in fact, not required.

[erichkeane]

@aaron.ballman s comments.

test/SemaCXX/cxx2a-user-defined-literals.cpp

24

Of course, the '9' in these two lines is now wrong... I'll fix it in my local copy.

[erichkeane]

test/SemaCXX/cxx2a-user-defined-literals.cpp

24

Actually not, since it was above the removed line... I need to stop working before my first caffeine infusion...

[aaron.ballman]

LGTM!

lib/Lex/LiteralSupport.cpp

815

Ahh, I see what's going on now. Thank you, this looks fine to me.

lib/Lex/LiteralSupport.cpp

 /// ParseDecimalOrOctalCommon - This method is called for decimal or octal
 /// numbers. It issues an error for illegal digits, and handles floating point
 /// parsing. If it detects a floating point number, the radix is set to 10.
 void NumericLiteralParser::ParseDecimalOrOctalCommon(SourceLocation TokLoc){
   assert((radix == 8 || radix == 10) && "Unexpected radix");
 
   // If we have a hex digit other than 'e' (which denotes a FP exponent) then
   // the code is using an incorrect base.
-  if (isHexDigit(*s) && *s != 'e' && *s != 'E') {
+  if (isHexDigit(*s) && *s != 'e' && *s != 'E' &&
+      !isValidUDSuffix(PP.getLangOpts(), StringRef(s, ThisTokEnd - s))) {
     PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin),
             diag::err_invalid_digit) << StringRef(s, 1) << (radix == 8 ? 1 : 0);
     hadError = true;
     return;
   }
 
   if (*s == '.') {
     checkSeparator(TokLoc, s, CSK_AfterDigits);
bool NumericLiteralParser::isValidUDSuffix(const LangOptions &LangOpts,
   // By C++11 [lex.ext]p10, ud-suffixes starting with an '_' are always valid.
   if (Suffix[0] == '_')
     return true;
 
   // In C++11, there are no library suffixes.
   if (!LangOpts.CPlusPlus14)
     return false;
 
-  // In C++1y, "s", "h", "min", "ms", "us", and "ns" are used in the library.
+  // In C++14, "s", "h", "min", "ms", "us", and "ns" are used in the library.
   // Per tweaked N3660, "il", "i", and "if" are also used in the library.
+  // In C++2a "d" and "y" are used in the library.
   return llvm::StringSwitch<bool>(Suffix)
       .Cases("h", "min", "s", true)
       .Cases("ms", "us", "ns", true)
       .Cases("il", "i", "if", true)
+      .Cases("d", "y", LangOpts.CPlusPlus2a)
       .Default(false);
 }
 
 void NumericLiteralParser::checkSeparator(SourceLocation TokLoc,
                                           const char *Pos,
                                           CheckSeparatorKind IsAfterDigits) {
   if (IsAfterDigits == CSK_AfterDigits) {
     if (Pos == ThisTokBegin)
PP.Diag(TokLoc,
                 : diag::ext_binary_literal);
     ++s;
     assert(s < ThisTokEnd && "didn't maximally munch?");
     radix = 2;
     DigitsBegin = s;
     s = SkipBinaryDigits(s);
     if (s == ThisTokEnd) {
       // Done.
-    } else if (isHexDigit(*s)) {
+    } else if (isHexDigit(*s) &&
+               !isValidUDSuffix(PP.getLangOpts(),
+                                StringRef(s, ThisTokEnd - s))) {
       PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin),
               diag::err_invalid_digit) << StringRef(s, 1) << 2;
       hadError = true;
     }
     // Other suffixes will be diagnosed by the caller.
     return;
   }
 

test/SemaCXX/cxx2a-user-defined-literals.cpp

+// RUN: %clang_cc1 -std=c++2a %s -include %s -verify
+
+#ifndef INCLUDED
+#define INCLUDED
+
+#pragma clang system_header
+namespace std {
+  namespace chrono {
+    struct day{};
+    struct year{};
+  }
+  constexpr chrono::day operator"" d(unsigned long long d) noexcept;
+  constexpr chrono::year operator"" y(unsigned long long y) noexcept;
+}
+
+#else
+
+using namespace std;
+chrono::day dec_d = 5d;
+chrono::day oct_d = 05d;
+chrono::day bin_d = 0b011d;
+// expected-error@+3{{no viable conversion from 'int' to 'chrono::day'}}
+// expected-note@9{{candidate constructor (the implicit copy constructor)}}
+// expected-note@9{{candidate constructor (the implicit move constructor)}}
+chrono::day hex_d = 0x44d;
+chrono::year y  = 10y;
+#endif