clang/test/SemaCXX/cxx11-user-defined-literals.cpp

   1 // RUN: %clang_cc1 -std=c++11 -verify %s -fms-extensions -triple x86_64-apple-darwin9.0.0
   2
   3 using size_t = decltype(sizeof(int));
   4 enum class LitKind {
   5   Char, WideChar, Char16, Char32,
   6   CharStr, WideStr, Char16Str, Char32Str,
   7   Integer, Floating, Raw, Template
   8 };
   9 constexpr LitKind operator"" _kind(char p) { return LitKind::Char; }
  10 constexpr LitKind operator"" _kind(wchar_t p) { return LitKind::WideChar; }
  11 constexpr LitKind operator"" _kind(char16_t p) { return LitKind::Char16; }
  12 constexpr LitKind operator"" _kind(char32_t p) { return LitKind::Char32; }
  13 constexpr LitKind operator"" _kind(const char *p, size_t n) { return LitKind::CharStr; }
  14 constexpr LitKind operator"" _kind(const wchar_t *p, size_t n) { return LitKind::WideStr; }
  15 constexpr LitKind operator"" _kind(const char16_t *p, size_t n) { return LitKind::Char16Str; }
  16 constexpr LitKind operator"" _kind(const char32_t *p, size_t n) { return LitKind::Char32Str; }
  17 constexpr LitKind operator"" _kind(unsigned long long n) { return LitKind::Integer; }
  18 constexpr LitKind operator"" _kind(long double n) { return LitKind::Floating; }
  19 constexpr LitKind operator"" _kind2(const char *p) { return LitKind::Raw; }
  20 template<char ...Cs> constexpr LitKind operator"" _kind3() { return LitKind::Template; }
  21
  22 static_assert('x'_kind == LitKind::Char, "");
  23 static_assert(L'x'_kind == LitKind::WideChar, "");
  24 static_assert(u'x'_kind == LitKind::Char16, "");
  25 static_assert(U'x'_kind == LitKind::Char32, "");
  26 static_assert("foo"_kind == LitKind::CharStr, "");
  27 static_assert(u8"foo"_kind == LitKind::CharStr, "");
  28 static_assert(L"foo"_kind == LitKind::WideStr, "");
  29 static_assert(u"foo"_kind == LitKind::Char16Str, "");
  30 static_assert(U"foo"_kind == LitKind::Char32Str, "");
  31 static_assert(194_kind == LitKind::Integer, "");
  32 static_assert(0377_kind == LitKind::Integer, "");
  33 static_assert(0x5ffc_kind == LitKind::Integer, "");
  34 static_assert(.5954_kind == LitKind::Floating, "");
  35 static_assert(1._kind == LitKind::Floating, "");
  36 static_assert(1.e-2_kind == LitKind::Floating, "");
  37 static_assert(4e6_kind == LitKind::Floating, "");
  38 static_assert(4e6_kind2 == LitKind::Raw, "");
  39 static_assert(4e6_kind3 == LitKind::Template, "");
  40
  41 constexpr const char *fractional_digits_impl(const char *p) {
  42   return *p == '.' ? p + 1 : *p ? fractional_digits_impl(p + 1) : 0;
  43 }
  44 constexpr const char *operator"" _fractional_digits(const char *p) {
  45   return fractional_digits_impl(p) ?: p;
  46 }
  47 constexpr bool streq(const char *p, const char *q) {
  48   return *p == *q && (!*p || streq(p+1, q+1));
  49 }
  50
  51 static_assert(streq(143.97_fractional_digits, "97"), "");
  52 static_assert(streq(0x786_fractional_digits, "0x786"), "");
  53 static_assert(streq(.4_fractional_digits, "4"), "");
  54 static_assert(streq(4._fractional_digits, ""), "");
  55 static_assert(streq(1e+97_fractional_digits, "1e+97"), "");
  56 static_assert(streq(0377_fractional_digits, "0377"), "");
  57 static_assert(streq(0377.5_fractional_digits, "5"), "");
  58
  59 int operator"" _ambiguous(char); // expected-note {{candidate}}
  60 namespace N {
  61   void *operator"" _ambiguous(char); // expected-note {{candidate}}
  62 }
  63 using namespace N;
  64 int k = 'x'_ambiguous; // expected-error {{ambiguous}}
  65
  66 int operator"" _deleted(unsigned long long) = delete; // expected-note {{here}}
  67 int m = 42_deleted; // expected-error {{attempt to use a deleted}}
  68
  69 namespace Using {
  70   namespace M {
  71     int operator"" _using(char);
  72   }
  73   int k1 = 'x'_using; // expected-error {{no matching literal operator for call to 'operator""_using'}}
  74
  75   using M::operator "" _using;
  76   int k2 = 'x'_using;
  77 }
  78
  79 namespace AmbiguousRawTemplate {
  80   int operator"" _ambig1(const char *); // expected-note {{candidate}}
  81   template<char...> int operator"" _ambig1(); // expected-note {{candidate}}
  82
  83   int k1 = 123_ambig1; // expected-error {{call to 'operator""_ambig1' is ambiguous}}
  84
  85   namespace Inner {
  86     template<char...> int operator"" _ambig2(); // expected-note 3{{candidate}}
  87   }
  88   int operator"" _ambig2(const char *); // expected-note 3{{candidate}}
  89   using Inner::operator"" _ambig2;
  90
  91   int k2 = 123_ambig2; // expected-error {{call to 'operator""_ambig2' is ambiguous}}
  92
  93   namespace N {
  94     using Inner::operator"" _ambig2;
  95
  96     int k3 = 123_ambig2; // ok
  97
  98     using AmbiguousRawTemplate::operator"" _ambig2;
  99
 100     int k4 = 123_ambig2; // expected-error {{ambiguous}}
 101
 102     namespace M {
 103
 104       template<char...> int operator"" _ambig2();
 105
 106       int k5 = 123_ambig2; // ok
 107     }
 108
 109     int operator"" _ambig2(unsigned long long);
 110
 111     int k6 = 123_ambig2; // ok
 112     int k7 = 123._ambig2; // expected-error {{ambiguous}}
 113   }
 114 }
 115
 116 constexpr unsigned mash(unsigned a) {
 117  return 0x93ae27b5 * ((a >> 13) | a << 19);
 118 }
 119 template<typename=void> constexpr unsigned hash(unsigned a) { return a; }
 120 template<char C, char...Cs> constexpr unsigned hash(unsigned a) {
 121  return hash<Cs...>(mash(a ^ mash(C)));
 122 }
 123 template<typename T, T v> struct constant { constexpr static T value = v; };
 124 template<char...Cs> constexpr unsigned operator"" _hash() {
 125   return constant<unsigned, hash<Cs...>(0)>::value;
 126 }
 127 static_assert(0x1234_hash == 0x103eff5e, "");
 128 static_assert(hash<'0', 'x', '1', '2', '3', '4'>(0) == 0x103eff5e, "");
 129
 130 // Functions and literal suffixes go in separate namespaces.
 131 namespace Namespace {
 132   template<char...> int operator"" _x();
 133   int k = _x(); // expected-error {{undeclared identifier '_x'}}
 134
 135   int _y(unsigned long long);
 136   int k2 = 123_y; // expected-error {{no matching literal operator for call to 'operator""_y'}}
 137 }
 138
 139 namespace PR14950 {
 140   template<...> // expected-error {{expected template parameter}}
 141   int operator"" _b(); // expected-error {{no function template matches function template specialization}}
 142   int main() { return 0_b; } // expected-error {{no matching literal operator for call to 'operator""_b'}}
 143 }
 144
 145 namespace bad_names {
 146   template<char...> int operator""_x();
 147
 148   template<typename T> void f() {
 149     class T:: // expected-error {{anonymous class}} expected-warning {{does not declare anything}}
 150         operator // expected-error {{expected identifier}}
 151             ""_q<'a'>;
 152
 153     T::template operator""_q<'a'>(); // expected-error {{non-namespace scope 'T::' cannot have a literal operator member}} expected-error +{{}}
 154     T::template operator""_q<'a'>::X; // expected-error {{non-namespace scope 'T::' cannot have a literal operator member}} expected-error +{{}}
 155     T::operator""_q<'a'>(); // expected-error {{non-namespace scope 'T::' cannot have a literal operator member}} expected-error +{{}}
 156     typename T::template operator""_q<'a'> a; // expected-error {{non-namespace scope 'T::' cannot have a literal operator member}} expected-error +{{}}
 157     typename T::operator""_q(""); // expected-error +{{}} expected-note {{to match}}
 158     T::operator""_q(""); // expected-error {{non-namespace scope 'T::' cannot have a literal operator member}}
 159
 160     bad_names::operator""_x<'a', 'b', 'c'>();
 161   };
 162
 163   struct S {};
 164   void g() {
 165     S::operator""_q(); // expected-error {{non-namespace scope 'S::' cannot have a literal operator member}}
 166   }
 167 }