[Clang] CWG1473: do not err on the lack of space after operator""

[rZhBoYao]

Summary

[Clang] CWG1473: do not err on the lack of space after operator""

In addition:

1. Fix tests for CWG2521 deprecation warning.
2. Enable -Wdeprecated-literal-operator by default.

Side note: GCC stopped diagnosing this since GCC 4.9

[rZhBoYao]

Reverse the dependency chain.

[Endill]

clang/test/CXX/drs/dr14xx.cpp

491

Can you move this down, so that offset is negative (after @)?

[rZhBoYao]

There seems to be no clear objection to this and https://reviews.llvm.org/D152632 and the CI are passing for both. Any chance that I merge these two before llvm 17 branch out (IIRC the next Monday)?

[rZhBoYao]

Gentle ping :)

[aaron.ballman]

LGTM aside from some minor concerns.

In D153156#4507440, @rZhBoYao wrote:

There seems to be no clear objection to this and https://reviews.llvm.org/D152632 and the CI are passing for both. Any chance that I merge these two before llvm 17 branch out (IIRC the next Monday)?

As this isn't fixing a regression, I think it'd be better to let it bake a while longer in Clang 18 (unless there's some extenuating circumstances where we need to land this sooner).

clang/test/SemaCXX/reserved-identifier.cpp

91–92

No need to have a duplicate test.

clang/www/cxx_dr_status.html

8648

[rZhBoYao]

Thank Aaron and Vlad for reviewing this! Just updating the diff to reflect the final version.

[steelannelida]

Unfortunately the option -Wno-reserved-user-defined-literal fails after this:

#define MYTHING "_something_"

const char* f() {
  return "ONE"MYTHING"TWO";
}

$ clang -Wno-reserved-user-defined-literal repro.cxx
repro.cxx:4:15: error: no matching literal operator for call to 'operator""MYTHING' with arguments of types 'const char *' and 'unsigned long', and no matching literal operator template
    4 |   return "ONE"MYTHING"TWO";
      |               ^
1 error generated.

[rZhBoYao]

In D153156#4598915, @steelannelida wrote:

Unfortunately the option -Wno-reserved-user-defined-literal fails after this:

#define MYTHING "_something_"

const char* f() {
  return "ONE"MYTHING"TWO";
}

$ clang -Wno-reserved-user-defined-literal repro.cxx
repro.cxx:4:15: error: no matching literal operator for call to 'operator""MYTHING' with arguments of types 'const char *' and 'unsigned long', and no matching literal operator template
    4 |   return "ONE"MYTHING"TWO";
      |               ^
1 error generated.

This is conforming right? Correct me if I'm wrong. My reading of https://eel.is/c++draft/lex.pptoken#3.3 is that "ONE"MYTHING"TWO" is a single preprocessing-token during phase 3 (https://eel.is/c++draft/lex.phases#1.3). Can @aaron.ballman confirm this?

[aaron.ballman]

In D153156#4598988, @rZhBoYao wrote:

In D153156#4598915, @steelannelida wrote:

Unfortunately the option -Wno-reserved-user-defined-literal fails after this:

#define MYTHING "_something_"

const char* f() {
  return "ONE"MYTHING"TWO";
}

$ clang -Wno-reserved-user-defined-literal repro.cxx
repro.cxx:4:15: error: no matching literal operator for call to 'operator""MYTHING' with arguments of types 'const char *' and 'unsigned long', and no matching literal operator template
    4 |   return "ONE"MYTHING"TWO";
      |               ^
1 error generated.

This is conforming right? Correct me if I'm wrong. My reading of https://eel.is/c++draft/lex.pptoken#3.3 is that "ONE"MYTHING"TWO" is a single preprocessing-token during phase 3 (https://eel.is/c++draft/lex.phases#1.3). Can @aaron.ballman confirm this?

The diagnostic behavior is correct. MYTHING doesn't get expanded until phase 4 (http://eel.is/c++draft/lex.phases#1.4), so this appears as "ONE"MYTHING as a single preprocessor token: https://eel.is/c++draft/lex.ext#nt:user-defined-string-literal and that token is an invalid UDL.

[rupprecht]

In D153156#4599106, @aaron.ballman wrote:

In D153156#4598988, @rZhBoYao wrote:

In D153156#4598915, @steelannelida wrote:

Unfortunately the option -Wno-reserved-user-defined-literal fails after this:

#define MYTHING "_something_"

const char* f() {
  return "ONE"MYTHING"TWO";
}

$ clang -Wno-reserved-user-defined-literal repro.cxx
repro.cxx:4:15: error: no matching literal operator for call to 'operator""MYTHING' with arguments of types 'const char *' and 'unsigned long', and no matching literal operator template
    4 |   return "ONE"MYTHING"TWO";
      |               ^
1 error generated.

This is conforming right? Correct me if I'm wrong. My reading of https://eel.is/c++draft/lex.pptoken#3.3 is that "ONE"MYTHING"TWO" is a single preprocessing-token during phase 3 (https://eel.is/c++draft/lex.phases#1.3). Can @aaron.ballman confirm this?

The diagnostic behavior is correct. MYTHING doesn't get expanded until phase 4 (http://eel.is/c++draft/lex.phases#1.4), so this appears as "ONE"MYTHING as a single preprocessor token: https://eel.is/c++draft/lex.ext#nt:user-defined-string-literal and that token is an invalid UDL.

IIUC, the question is not whether the diagnostic is correct, but rather why -Wno-reserved-user-defined-literal does not workaround the breakage. Is that right?

An example of this in the wild is older versions of swig: https://github.com/swig/swig/blob/939dd5e1c8c17e5f8b38747bf18e9041ab5f377e/Source/Modules/php.cxx#L1724

[jyknight]

The diagnostic behavior is correct. MYTHING doesn't get expanded until phase 4 (http://eel.is/c++draft/lex.phases#1.4), so this appears as "ONE"MYTHING as a single preprocessor token: https://eel.is/c++draft/lex.ext#nt:user-defined-string-literal and that token is an invalid UDL.

Correct per the specification, but the purpose of -Wno-reserved-user-defined-literal is to precisely to permit such pre-C++11 code like the example above to continue to compile. This change breaks that option. (Note that it is an error-by-default "warning".)

If proper spec-conformance means we can no longer support the ability to allow such out-of-spec pre-c++11 code to work anymore, that's probably OK...but, in that case, we also need to eliminate the warning option, and mention the change in the release notes.

However, it's unclear to me why we need to do so, since the spec says you're not allowed to define UDL without an underscore prefix
float operator ""E(const char*); // ill-formed, no diagnostic required:

Yet, what this change does, and why it breaks the above functionality, is that it now allows defining and calling user-defined literal operators which don't begin with an underscore. That seems like a potentially undesirable change?

And, if that _was_ an intended change, then we have other diagnostics which need to be fixed up now:

const char*operator ""foo(const char *, unsigned long);
const char* f() {
  return "hi"foo;
}

emits <source>:1:12: warning: user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator [-Wuser-defined-literals] and yet, now it does invoke the operator...

[rZhBoYao]

In D153156#4599324, @jyknight wrote:

If proper spec-conformance means we can no longer support the ability to allow such out-of-spec pre-c++11 code to work anymore, that's probably OK...but, in that case, we also need to eliminate the warning option, and mention the change in the release notes.

Works in C++98 mode tho. TIL people exploit this to mix pre-C++11 code into modern C++. I agree that a reminder for those people in the release note is needed.

And, if that _was_ an intended change, then we have other diagnostics which need to be fixed up now

Agreed

In D153156#4599292, @rupprecht wrote:

IIUC, the question is not whether the diagnostic is correct, but rather why -Wno-reserved-user-defined-literal does not workaround the breakage. Is that right?

An example of this in the wild is older versions of swig: https://github.com/swig/swig/blob/939dd5e1c8c17e5f8b38747bf18e9041ab5f377e/Source/Modules/php.cxx#L1724

We simply stop pretending a whitespace precedes an invalid ud-suffix as that affects the grammar production and therefore diagnosis in Sema.
IMHO, people should stop using -Wno-reserved-user-defined-literal and exploiting the addition of a whitespace to mingle pre-c++11 and post-c++11 code.
What if a programmer is really trying to call operator""b here (albeit ill-formed):

const char* operator""b(const char*, decltype(sizeof 0));
const char* f() {
#define b "a"
  return "ONE"b; // NOW: IFNDR but calls operator""b
                 //
                 // BEFORE: string concat by exploiting the impl of
                 // ext_reserved_user_defined_literal (controlled by
                 // -Wreserved-user-defined-literal diag group)
}

[jyknight]

In D153156#4599595, @rZhBoYao wrote:

What if a programmer is really trying to call operator""b here (albeit ill-formed)

Because that code is ill-formed, Clang diagnosed it with an error by default. Isn't that preferable to accepting it by default?

And disabling the error treats it as string-concat, because that enables users to remain compatible with code written assuming C++98 semantics for macros in string concatenation. (This support was a quite-intentionally added feature, not an accident of implementation!)

FWIW, GCC does the same thing, but with an on-by-default-warning that doesn't even default to error severity. I do think it's OK to remove support for this extension if spec-compliance requires it, but AFAICT, that's not the case here, so I think it would be preferable to preserve the previous behavior.

[rZhBoYao]

I’ll see what I can do regarding reviving the string concat behavior. It feels like that a more refined treatment than before can be achieved. Maybe adds an imaginary preceding whitespace only when we can find a macro with the same name.

[rupprecht]

The other common breakage I'm seeing is code that hasn't yet migrated from the "PRI" format macros, of which there's an example in LLVM itself: https://github.com/llvm/llvm-project/blob/6a0e536ccfef1f7bd64ee4153b4efc0aeecf28d4/clang/test/SemaCXX/cxx11-compat.cpp#L38

e.g.: https://godbolt.org/z/v3boc9E6T

IMHO, people should stop using -Wno-reserved-user-defined-literal and exploiting the addition of a whitespace to mingle pre-c++11 and post-c++11 code.

I mostly agree with this, at least the spirit of it, but do we usually remove the -Wno ability to suppress a common error because we don't like it? (Or justify it post-facto if we accidentally did that?) If removing this is important for some other aspect of clang development, it would be nice to have notice ahead of time that this option will go away. I guess +1 to what James said.

[rupprecht]

In D153156#4600270, @rupprecht wrote:

of which there's an example in LLVM itself: https://github.com/llvm/llvm-project/blob/6a0e536ccfef1f7bd64ee4153b4efc0aeecf28d4/clang/test/SemaCXX/cxx11-compat.cpp#L38

Sorry, I don't want to mislead: I just mean there's a handy example in clang's unit tests. I don't see any instances of this in LLVM non-test code.

[rZhBoYao]

D158372 addresses comments.

[hans]

Given the concerns raised (the PRIuS one in https://godbolt.org/z/v3boc9E6T seems like a good example), and that the fix in D158372 doesn't seem straight-forward, could this be reverted to unbreak things until a revised version is ready?

@aaron.ballman what do you think?

[aaron.ballman]

In D153156#4607576, @hans wrote:

Given the concerns raised (the PRIuS one in https://godbolt.org/z/v3boc9E6T seems like a good example), and that the fix in D158372 doesn't seem straight-forward, could this be reverted to unbreak things until a revised version is ready?

@aaron.ballman what do you think?

I agree this should be reverted from 17.x so we have more time to consider an appropriate path forward. Supporting evidence that this will likely be disruptive: https://sourcegraph.com/search?q=context:global+%5E%28%22%5B%5E%22%5D%2B%22PRI.*%29%24+lang:C%2B%2B+-file:.*test.*&patternType=regexp&case=yes&sm=0&groupBy=repo

[hans]

In D153156#4607655, @aaron.ballman wrote:

I agree this should be reverted from 17.x so we have more time to consider an appropriate path forward. Supporting evidence that this will likely be disruptive: https://sourcegraph.com/search?q=context:global+%5E%28%22%5B%5E%22%5D%2B%22PRI.*%29%24+lang:C%2B%2B+-file:.*test.*&patternType=regexp&case=yes&sm=0&groupBy=repo

I don't believe this is on 17.x. I'm suggesting reverting to green on trunk.

[aaron.ballman]

In D153156#4607671, @hans wrote:

In D153156#4607655, @aaron.ballman wrote:

I agree this should be reverted from 17.x so we have more time to consider an appropriate path forward. Supporting evidence that this will likely be disruptive: https://sourcegraph.com/search?q=context:global+%5E%28%22%5B%5E%22%5D%2B%22PRI.*%29%24+lang:C%2B%2B+-file:.*test.*&patternType=regexp&case=yes&sm=0&groupBy=repo

I don't believe this is on 17.x. I'm suggesting reverting to green on trunk.

Heh, review fatigue caught me; I even mentioned on this review that it should not go into 17.x so we get more bake time with it! Sorry for that.

I think it is beneficial for us to get more feedback on problems caused by the changes, in case they help us decide how we want to move forward solving them. However, if the changes on trunk are sufficiently disruptive that we probably won't get more (novel) feedback anyway, then I think a revert is reasonable.

[rnk]

I went ahead and pushed a revert of this, since this change was pretty disruptive, at least in our experience. I could be convinced that it's worth sunsetting this extension for accepting C-style format string macro code, but that doesn't seem like the original intent of this change. Maybe that's the right thing to do, but it should be an intentionally considered change.

[sunmy2019]

For note: it possibly break fmtlib. https://github.com/fmtlib/fmt/issues/3607

[jyknight]

Reopening the review since it ended up reverted, but I do think we DO want to have at least some of the changes proposed here (and/or from the pending D158372). At the very least, the existing diagnostics are currently quite misleading/wrong, and the work here was helping to improve that.

Taking this example:

float operator ""XXX(const char *);

It results in three diagnostics:

<source>:1:18: error: invalid suffix on literal; C++11 requires a space between literal and identifier [-Wreserved-user-defined-literal]
    1 | float operator ""XXX(const char *);
      |                  ^
      |                   
<source>:1:18: warning: identifier 'XXX' preceded by whitespace in a literal operator declaration is deprecated [-Wdeprecated-literal-operator]
    1 | float operator ""XXX(const char *);
      |       ~~~~~~~~~~~^~~
      |       operator""XXX
<source>:1:7: warning: user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator [-Wuser-defined-literals]
    1 | float operator ""XXX(const char *);
      |       ^

The first and third are enabled by default, the second is not.

The first only describes what to do if you wanted it to be string-concat (which would be invalid here...), not if you wanted it to be an UDL-operator definition. And it's not clear that "identifier" really means "macro expanding to a string that I assume you meant" in the message. I think we should not emit that message ONLY if there is a macro named "XXX".

The second is just incorrect -- there's already no space in the user’s source-code, the compiler just added one internally!

The third seems OK, although if we actually do permit calling such UDLs, would want to remove the last phrase...

Then, consider:

float operator ""XXX(const char *);
float x1 = ""XXX;

One might reasonably expect to build when -Wno-reserved-user-defined-literal is specified. But, currently, it does not.

I think a reasonable compromise behavior would be:

1. If the literal suffix is nonstandard (that is: doesn't start with _, and isn't a standard-defined UDL suffix), then try macro-expanding the suffix.
2. If there is an expansion, use the macro-expansion, instead of treating it as UDL, and diagnose as an error-by-default under -Wreserved-user-defined-literal.
3. On the other hand, if there is no macro-expansion, then let it be parsed as a nonstandard UDL, and emit a different diagnostic message under error-by-default -Wreserved-user-defined-literal.

clang/docs/ReleaseNotes.rst

 
 - Attributes now expect unevaluated strings in attributes parameters that are string literals.
   This is applied to both C++ standard attributes, and other attributes supported by Clang.
   This completes the implementation of `P2361R6 Unevaluated Strings <https://wg21.link/P2361R6>`_
 
 
 Resolutions to C++ Defect Reports
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Implemented `CWG1473 <https://wg21.link/CWG1473>`_ which allows spaces after ``operator""``.
+  Clang used to err on the lack of space when the literal suffix identifier was invalid in
+  all the language modes, which contradicted the deprecation of the whitespaces.
+  Also turn on ``-Wdeprecated-literal-operator`` by default in all the language modes.
 
 C Language Changes
 ------------------
 - ``structs``, ``unions``, and ``arrays`` that are const may now be used as
   constant expressions.  This change is more consistent with the behavior of
   GCC.
 
 C23 Feature Support

clang/include/clang/Basic/DiagnosticLexKinds.td

def warn_cxx14_compat_u8_character_literal : Warning<
   InGroup<CXXPre17Compat>, DefaultIgnore;
 def warn_cxx11_compat_user_defined_literal : Warning<
   "identifier after literal will be treated as a user-defined literal suffix "
   "in C++11">, InGroup<CXX11Compat>, DefaultIgnore;
 def warn_cxx11_compat_reserved_user_defined_literal : Warning<
   "identifier after literal will be treated as a reserved user-defined literal "
   "suffix in C++11">,
   InGroup<CXX11CompatReservedUserDefinedLiteral>, DefaultIgnore;
-def ext_reserved_user_defined_literal : ExtWarn<
-  "invalid suffix on literal; C++11 requires a space between literal and "
-  "identifier">, InGroup<ReservedUserDefinedLiteral>, DefaultError;
-def ext_ms_reserved_user_defined_literal : ExtWarn<
-  "invalid suffix on literal; C++11 requires a space between literal and "
-  "identifier">, InGroup<ReservedUserDefinedLiteral>;
 def err_unsupported_string_concat : Error<
   "unsupported non-standard concatenation of string literals">;
 
 def warn_unevaluated_string_prefix : Warning<
   "encoding prefix '%0' on an unevaluated string literal has no effect"
   "%select{| and is incompatible with c++2c}1">,
   InGroup<DiagGroup<"invalid-unevaluated-string">>;
 def err_unevaluated_string_prefix : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_reserved_extern_symbol: Warning<
   "it starts with '_' at global scope|"
   "it starts with '_' and has C language linkage|"
   "it starts with '__'|"
   "it starts with '_' followed by a capital letter|"
   "it contains '__'}1">,
   InGroup<ReservedIdentifier>, DefaultIgnore;
 def warn_deprecated_literal_operator_id: Warning<
   "identifier %0 preceded by whitespace in a literal operator declaration "
-  "is deprecated">, InGroup<DeprecatedLiteralOperator>, DefaultIgnore;
+  "is deprecated">, InGroup<DeprecatedLiteralOperator>;
 def warn_reserved_module_name : Warning<
   "%0 is a reserved name for a module">, InGroup<ReservedModuleIdentifier>;
 
 def warn_parameter_size: Warning<
   "%0 is a large (%1 bytes) pass-by-value argument; "
   "pass it by reference instead ?">, InGroup<LargeByValueCopy>;
 def warn_return_value_size: Warning<
   "return value of %0 is a large (%1 bytes) pass-by-value object; "

clang/lib/Lex/Lexer.cpp

if (!isLexingRawMode())
       Diag(CurPtr,
            C == '_' ? diag::warn_cxx11_compat_user_defined_literal
                     : diag::warn_cxx11_compat_reserved_user_defined_literal)
         << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
     return CurPtr;
   }
 
   // C++11 [lex.ext]p10, [usrlit.suffix]p1: A program containing a ud-suffix
-  // that does not start with an underscore is ill-formed. As a conforming
-  // extension, we treat all such suffixes as if they had whitespace before
-  // them. We assume a suffix beginning with a UCN or UTF-8 character is more
-  // likely to be a ud-suffix than a macro, however, and accept that.
-  if (!Consumed) {
-    bool IsUDSuffix = false;
-    if (C == '_')
-      IsUDSuffix = true;
-    else if (IsStringLiteral && LangOpts.CPlusPlus14) {
-      // In C++1y, we need to look ahead a few characters to see if this is a
-      // valid suffix for a string literal or a numeric literal (this could be
-      // the 'operator""if' defining a numeric literal operator).
-      const unsigned MaxStandardSuffixLength = 3;
-      char Buffer[MaxStandardSuffixLength] = { C };
-      unsigned Consumed = Size;
-      unsigned Chars = 1;
-      while (true) {
-        unsigned NextSize;
-        char Next = getCharAndSizeNoWarn(CurPtr + Consumed, NextSize, LangOpts);
-        if (!isAsciiIdentifierContinue(Next)) {
-          // End of suffix. Check whether this is on the allowed list.
-          const StringRef CompleteSuffix(Buffer, Chars);
-          IsUDSuffix =
-              StringLiteralParser::isValidUDSuffix(LangOpts, CompleteSuffix);
-          break;
-        }
-
-        if (Chars == MaxStandardSuffixLength)
-          // Too long: can't be a standard suffix.
-          break;
-
-        Buffer[Chars++] = Next;
-        Consumed += NextSize;
-      }
-    }
-
-    if (!IsUDSuffix) {
-      if (!isLexingRawMode())
-        Diag(CurPtr, LangOpts.MSVCCompat
-                         ? diag::ext_ms_reserved_user_defined_literal
-                         : diag::ext_reserved_user_defined_literal)
-            << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
-      return CurPtr;
-    }
-
+  // that does not start with an underscore is ill-formed. We assume a suffix
+  // beginning with a UCN or UTF-8 character is more likely to be a ud-suffix
+  // than a macro, however, and accept that.
+  if (!Consumed)
     CurPtr = ConsumeChar(CurPtr, Size, Result);
-  }
 
   Result.setFlag(Token::HasUDSuffix);
   while (true) {
     C = getCharAndSize(CurPtr, Size);
     if (isAsciiIdentifierContinue(C)) {
       CurPtr = ConsumeChar(CurPtr, Size, Result);
     } else if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result)) {
     } else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr)) {

clang/test/CXX/drs/dr14xx.cpp

 #endif
     f({uR"(abc)"});   // expected-error {{call to deleted function 'f'}}
     f({(UR"(abc)")}); // expected-error {{call to deleted function 'f'}}
   }
   } // namespace StringLiterals
 #endif
 } // dr1467
 
+namespace dr1473 { // dr1473: 18
+                   // NB: sup 1762, test reused there
+#if __cplusplus >= 201103L
+  float operator ""_E(const char *);
+  float operator ""E(const char *); // don't err on the lack of spaces even when the literal suffix identifier is invalid
+  // expected-warning@-1 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
+#endif
+}
+
 namespace dr1479 { // dr1479: yes
-  int operator"" _a(const char*, std::size_t = 0); // expected-error {{literal operator cannot have a default argument}}
+  int operator""_a(const char*, std::size_t = 0); // expected-error {{literal operator cannot have a default argument}}
 }
 
 namespace dr1482 { // dr1482: yes
                    // NB: sup 2516, test reused there
 #if __cplusplus >= 201103L
 template <typename T> struct S {
   typedef char I;
 };

clang/test/CXX/drs/dr17xx.cpp

#if __cplusplus >= 201103L
   struct B {
     operator A() { return A(); }
   } b;
   A a{b};
 #endif
 }
 
 namespace dr1762 { // dr1762: 14
+                   // NB: reusing 1473 test
 #if __cplusplus >= 201103L
   float operator ""_E(const char *);
-  // expected-error@+2 {{invalid suffix on literal; C++11 requires a space between literal and identifier}}
-  // expected-warning@+1 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
   float operator ""E(const char *);
+  // expected-warning@-1 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
 #endif
 }
 
 namespace dr1778 { // dr1778: 9
   // Superseded by P1286R2.
 #if __cplusplus >= 201103L
   struct A { A() noexcept(true) = default; };
   struct B { B() noexcept(false) = default; };

clang/test/CXX/drs/dr25xx.cpp

int test_specialization() {
   S<double> s3; // expected-note {{in instantiation of template class 'dr2518::S<double>' requested here}}
 }
 #endif
 
 }
 
 namespace dr2521 { // dr2521: 17
 #if __cplusplus >= 201103L
-#pragma clang diagnostic push
-#pragma clang diagnostic warning "-Wdeprecated-literal-operator"
 long double operator""      _\u03C0___(long double);
 // expected-warning@-1 {{identifier '_π___' preceded by whitespace in a literal operator declaration is deprecated}}
 // expected-warning@-2 {{user-defined literal suffixes containing '__' are reserved}}
 
 template <char... Chars> decltype(sizeof 0)
 operator""  _div();
 // expected-warning@-1 {{identifier '_div' preceded by whitespace in a literal operator declaration is deprecated}}
 
 using ::dr2521::operator"" _\u03C0___;
 using ::dr2521::operator""_div;
 // expected-warning@-2 {{identifier '_π___' preceded by whitespace in a literal operator declaration is deprecated}}
-#pragma clang diagnostic pop
 #endif
 } // namespace dr2521
 
 namespace dr2565 { // dr2565: 16 open
 #if __cplusplus >= 202002L
   template<typename T>
     concept C = requires (typename T::type x) {
       x + 1;

clang/test/CXX/lex/lex.literal/lex.ext/p1.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
-void operator "" p31(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
-void operator "" _p31(long double);
-long double operator "" pi(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
+void operator ""p31(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
+void operator ""_p31(long double);
+long double operator ""pi(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
 
 float hexfloat = 0x1p31; // allow hexfloats

clang/test/CXX/lex/lex.literal/lex.ext/p10.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
 using size_t = decltype(sizeof(int));
-void operator "" wibble(const char *); // expected-warning {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
-void operator "" wibble(const char *, size_t); // expected-warning {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
+void operator ""wibble(const char *); // expected-warning {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
+void operator ""wibble(const char *, size_t); // expected-warning {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
 
 template<typename T>
 void f() {
   // A program containing a reserved ud-suffix is ill-formed.
   123wibble; // expected-error {{invalid suffix 'wibble'}}
   123.0wibble; // expected-error {{invalid suffix 'wibble'}}
-  const char *p = ""wibble; // expected-error {{invalid suffix on literal; C++11 requires a space between literal and identifier}} expected-error {{expected ';'}}
-  const char *q = R"x("hello")x"wibble; // expected-error {{invalid suffix on literal; C++11 requires a space between literal and identifier}} expected-error {{expected ';'}}
+  const char *p = ""wibble; // expected-error {{cannot initialize a variable of type 'const char *' with an rvalue of type 'void'}}
+  const char *q = R"x("hello")x"wibble; // expected-error {{cannot initialize a variable of type 'const char *' with an rvalue of type 'void'}}
 }

clang/test/CXX/lex/lex.literal/lex.ext/p11.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
 using size_t = decltype(sizeof(int));
 
 template<typename T, typename U> struct same_type;
 template<typename T> struct same_type<T, T> {};
 template<typename T> using X = T;
 template<typename CharT, X<CharT>...>
-int operator "" _x(); // expected-warning {{string literal operator templates are a GNU extension}}
+int operator ""_x(); // expected-warning {{string literal operator templates are a GNU extension}}
 template<char...>
-double operator "" _x();
+double operator ""_x();
 
 auto a="string"_x;
 auto b=42_x;
 same_type<decltype(a), int> test_a;
 same_type<decltype(b), double> test_b;
 
-char operator "" _x(const char *begin, size_t size);
+char operator ""_x(const char *begin, size_t size);
 auto c="string"_x;
 auto d=L"string"_x;
 same_type<decltype(c), char> test_c;
 same_type<decltype(d), int> test_d;

clang/test/CXX/lex/lex.literal/lex.ext/p3.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
-int &operator "" _x1 (unsigned long long);
+int &operator ""_x1 (unsigned long long);
 int &i1 = 0x123_x1;
 
-double &operator "" _x1 (const char *);
+double &operator ""_x1 (const char *);
 int &i2 = 45_x1;
 
-template<char...> char &operator "" _x1 ();
+template<char...> char &operator ""_x1 ();
 int &i3 = 0377_x1;
 
 int &i4 = 90000000000000000000000000000000000000000000000_x1; // expected-error {{integer literal is too large to be represented in any integer type}}
 
-double &operator "" _x2 (const char *);
+double &operator ""_x2 (const char *);
 double &i5 = 123123123123123123123123123123123123123123123_x2;
 
-template<char...Cs> constexpr int operator "" _x3() { return sizeof...(Cs); }
+template<char...Cs> constexpr int operator ""_x3() { return sizeof...(Cs); }
 static_assert(123456789012345678901234567890123456789012345678901234567890_x3 == 60, "");

clang/test/CXX/lex/lex.literal/lex.ext/p4.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
-int &operator "" _x1 (long double);
+int &operator ""_x1 (long double);
 int &i1 = 0.123_x1;
 
-double &operator "" _x1 (const char *);
+double &operator ""_x1 (const char *);
 int &i2 = 45._x1;
 
-template<char...> char &operator "" _x1 ();
+template<char...> char &operator ""_x1 ();
 int &i3 = 0377e-1_x1;
 
 int &i4 = 1e1000000_x1; // expected-warning {{too large for type 'long double'}}
 
-double &operator "" _x2 (const char *);
+double &operator ""_x2 (const char *);
 double &i5 = 1e1000000_x2;
 
-template<char...Cs> constexpr int operator "" _x3() { return sizeof...(Cs); }
+template<char...Cs> constexpr int operator ""_x3() { return sizeof...(Cs); }
 static_assert(1e1000000_x3 == 9, "");

clang/test/CXX/lex/lex.literal/lex.ext/p5.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s -fcxx-exceptions -triple=x86_64-linux-gnu
 // RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s -fcxx-exceptions -triple=x86_64-linux-gnu
 
 using size_t = decltype(sizeof(int));
 
-int &operator "" _x1 (const char *);
-double &operator "" _x1 (const char *, size_t);
+int &operator ""_x1 (const char *);
+double &operator ""_x1 (const char *, size_t);
 double &i1 = "foo"_x1;
 #if __cplusplus >= 202002L
 using char8 = float;
-float &operator "" _x1 (const char8_t *, size_t);
+float &operator ""_x1 (const char8_t *, size_t);
 #else
 using char8 = double;
 #endif
 char8 &i2 = u8"foo"_x1;
 double &i3 = L"foo"_x1; // expected-error {{no matching literal operator for call to 'operator""_x1' with arguments of types 'const wchar_t *' and 'unsigned long'}}
 
-char &operator "" _x1(const wchar_t *, size_t);
+char &operator ""_x1(const wchar_t *, size_t);
 char &i4 = L"foo"_x1; // ok
 double &i5 = R"(foo)"_x1; // ok
 char8 &i6 = u\
 8\
 R\
 "(foo)"\
 _\
 x\

clang/test/CXX/lex/lex.literal/lex.ext/p6.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
 using size_t = decltype(sizeof(int));
 
-int &operator "" _x1 (const char *);
+int &operator ""_x1 (const char *);
 double &i1 = 'a'_x1; // expected-error {{no matching literal operator}}
-double &operator "" _x1 (wchar_t);
+double &operator ""_x1 (wchar_t);
 double &i2 = L'a'_x1;
 double &i3 = 'a'_x1; // expected-error {{no matching literal operator}}
-double &i4 = operator"" _x1('a'); // ok
+double &i4 = operator""_x1('a'); // ok
 
-char &operator "" _x1(char16_t);
+char &operator ""_x1(char16_t);
 char &i5 = u'a'_x1; // ok
 double &i6 = L'a'_x1; // ok

clang/test/CXX/lex/lex.literal/lex.ext/p7.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s -triple=x86_64-linux-gnu
 
 using size_t = decltype(sizeof(int));
 namespace std {
   struct string {};
 }
 
 template<typename T, typename U> struct same_type;
 template<typename T> struct same_type<T, T> {};
 
 namespace std_example {
 
-long double operator "" _w(long double);
-std::string operator "" _w(const char16_t*, size_t);
-unsigned operator "" _w(const char*);
+long double operator ""_w(long double);
+std::string operator ""_w(const char16_t*, size_t);
+unsigned operator ""_w(const char*);
 int main() {
   auto v1 = 1.2_w;    // calls operator""_w(1.2L)
   auto v2 = u"one"_w; // calls operator""_w(u"one", 3)
   auto v3 = 12_w;     // calls operator""_w("12")
   "two"_w;            // expected-error {{no matching literal operator for call to 'operator""_w' with arguments of types 'const char *' and 'unsigned long'}}
 
   same_type<decltype(v1), long double> test1;
   same_type<decltype(v2), std::string> test2;
   same_type<decltype(v3), unsigned> test3;
 }
 
 }

clang/test/CXX/lex/lex.literal/lex.ext/p8.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
 using size_t = decltype(sizeof(int));
-constexpr const char *operator "" _id(const char *p, size_t) { return p; }
+constexpr const char *operator ""_id(const char *p, size_t) { return p; }
 constexpr const char *s = "foo"_id "bar" "baz"_id "quux";
 
 constexpr bool streq(const char *p, const char *q) {
   return *p == *q && (!*p || streq(p+1, q+1));
 }
 static_assert(streq(s, "foobarbazquux"), "");
 
-constexpr const char *operator "" _trim(const char *p, size_t n) {
-  return *p == ' ' ? operator "" _trim(p + 1, n - 1) : p;
+constexpr const char *operator ""_trim(const char *p, size_t n) {
+  return *p == ' ' ? operator ""_trim(p + 1, n - 1) : p;
 }
 constexpr const char *t = "   " " "_trim "  foo";
 static_assert(streq(t, "foo"), "");
 
 const char *u = "foo" "bar"_id "baz" "quux"_di "corge"; // expected-error {{differing user-defined suffixes ('_id' and '_di') in string literal concatenation}}

clang/test/CXX/lex/lex.literal/lex.ext/p9.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
 using size_t = decltype(sizeof(int));
-void operator "" _x(const wchar_t *, size_t);
+void operator ""_x(const wchar_t *, size_t);
 
 namespace std_example {
 
 int main() {
   L"A" "B" "C"_x;
   "P"_x "Q" "R"_y; // expected-error {{differing user-defined suffixes ('_x' and '_y') in string literal concatenation}}
 }
 
 }

clang/test/CXX/over/over.oper/over.literal/p2.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
-void operator "" _a(const char *);
+void operator ""_a(const char *);
 
 namespace N {
-  using ::operator "" _a;
+  using ::operator ""_a;
 
-  void operator "" _b(const char *);
+  void operator ""_b(const char *);
 }
 
-using N::operator "" _b;
+using N::operator ""_b;
 
 class C {
-  void operator "" _c(const char *); // expected-error {{must be in a namespace or global scope}}
+  void operator ""_c(const char *); // expected-error {{must be in a namespace or global scope}}
 
-  static void operator "" _c(unsigned long long); // expected-error {{must be in a namespace or global scope}}
+  static void operator ""_c(unsigned long long); // expected-error {{must be in a namespace or global scope}}
 
-  friend void operator "" _d(const char *);
+  friend void operator ""_d(const char *);
 };
 
-int operator "" _e; // expected-error {{cannot be the name of a variable}}
+int operator ""_e; // expected-error {{cannot be the name of a variable}}
 
 void f() {
-  int operator "" _f; // expected-error {{cannot be the name of a variable}}
+  int operator ""_f; // expected-error {{cannot be the name of a variable}}
 }
 
 extern "C++" {
-  void operator "" _g(const char *);
+  void operator ""_g(const char *);
 }
 
-template<char...> void operator "" _h() {}
+template<char...> void operator ""_h() {}
 
-template<> void operator "" _h<'a', 'b', 'c'>() {}
+template<> void operator ""_h<'a', 'b', 'c'>() {}
 
-template void operator "" _h<'a', 'b', 'c', 'd'>();
+template void operator ""_h<'a', 'b', 'c', 'd'>();
 
 namespace rdar13605348 {
 
 class C {
-  double operator"" _x(long double value) { return double(value); } // expected-error{{literal operator 'operator""_x' must be in a namespace or global scope}}
+  double operator""_x(long double value) { return double(value); } // expected-error{{literal operator 'operator""_x' must be in a namespace or global scope}}
   double value() { return 3.2_x; } // expected-error{{no matching literal operator for call to}}
 };
 
 }

clang/test/CXX/over/over.oper/over.literal/p3.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 using size_t = decltype(sizeof(int));
 
 // Acceptable parameter declarations
-char operator "" _a(const char *);
-char operator "" _a(const char []);
-char operator "" _a(unsigned long long);
-char operator "" _a(long double);
-char operator "" _a(char);
-char operator "" _a(const volatile char);
-char operator "" _a(wchar_t);
-char operator "" _a(char16_t);
-char operator "" _a(char32_t);
-char operator "" _a(const char *, size_t);
-char operator "" _a(const wchar_t *, size_t);
-char operator "" _a(const char16_t *, size_t);
-char operator "" _a(const char32_t *, size_t);
-char operator "" _a(const char [32], size_t);
+char operator ""_a(const char *);
+char operator ""_a(const char []);
+char operator ""_a(unsigned long long);
+char operator ""_a(long double);
+char operator ""_a(char);
+char operator ""_a(const volatile char);
+char operator ""_a(wchar_t);
+char operator ""_a(char16_t);
+char operator ""_a(char32_t);
+char operator ""_a(const char *, size_t);
+char operator ""_a(const wchar_t *, size_t);
+char operator ""_a(const char16_t *, size_t);
+char operator ""_a(const char32_t *, size_t);
+char operator ""_a(const char [32], size_t);
 
 // Unacceptable parameter declarations
-char operator "" _b(); // expected-error {{parameter}}
-char operator "" _b(const wchar_t *); // expected-error {{parameter}}
-char operator "" _b(long long); // expected-error {{parameter}}
-char operator "" _b(double); // expected-error {{parameter}}
-char operator "" _b(short); // expected-error {{parameter}}
-char operator "" _a(char, int = 0); // expected-error {{parameter}}
-char operator "" _b(unsigned short); // expected-error {{parameter}}
-char operator "" _b(signed char); // expected-error {{parameter}}
-char operator "" _b(unsigned char); // expected-error {{parameter}}
-char operator "" _b(const short *, size_t); // expected-error {{parameter}}
-char operator "" _b(const unsigned short *, size_t); // expected-error {{parameter}}
-char operator "" _b(const signed char *, size_t); // expected-error {{parameter}}
-char operator "" _b(const unsigned char *, size_t); // expected-error {{parameter}}
-char operator "" _a(const volatile char *, size_t); // expected-error {{parameter}}
-char operator "" _a(volatile wchar_t *, size_t); // expected-error {{parameter}}
-char operator "" _a(char16_t *, size_t); // expected-error {{parameter}}
-char operator "" _a(const char32_t *, size_t, bool = false); // expected-error {{parameter}}
-char operator "" _a(const char *, signed long); // expected-error {{parameter}}
-char operator "" _a(const char *, size_t = 0); // expected-error {{default argument}}
+char operator ""_b(); // expected-error {{parameter}}
+char operator ""_b(const wchar_t *); // expected-error {{parameter}}
+char operator ""_b(long long); // expected-error {{parameter}}
+char operator ""_b(double); // expected-error {{parameter}}
+char operator ""_b(short); // expected-error {{parameter}}
+char operator ""_a(char, int = 0); // expected-error {{parameter}}
+char operator ""_b(unsigned short); // expected-error {{parameter}}
+char operator ""_b(signed char); // expected-error {{parameter}}
+char operator ""_b(unsigned char); // expected-error {{parameter}}
+char operator ""_b(const short *, size_t); // expected-error {{parameter}}
+char operator ""_b(const unsigned short *, size_t); // expected-error {{parameter}}
+char operator ""_b(const signed char *, size_t); // expected-error {{parameter}}
+char operator ""_b(const unsigned char *, size_t); // expected-error {{parameter}}
+char operator ""_a(const volatile char *, size_t); // expected-error {{parameter}}
+char operator ""_a(volatile wchar_t *, size_t); // expected-error {{parameter}}
+char operator ""_a(char16_t *, size_t); // expected-error {{parameter}}
+char operator ""_a(const char32_t *, size_t, bool = false); // expected-error {{parameter}}
+char operator ""_a(const char *, signed long); // expected-error {{parameter}}
+char operator ""_a(const char *, size_t = 0); // expected-error {{default argument}}

clang/test/CXX/over/over.oper/over.literal/p5.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 using size_t = decltype(sizeof(int));
 template<char...> struct S {};
 
-template<char...> void operator "" _a();
-template<char... C> S<C...> operator "" _a();
+template<char...> void operator ""_a();
+template<char... C> S<C...> operator ""_a();
 
 template<typename T> struct U {
-  friend int operator "" _a(const char *, size_t);
+  friend int operator ""_a(const char *, size_t);
   // FIXME: It's not entirely clear whether this is intended to be legal.
-  friend U operator "" _a(const T *, size_t); // expected-error {{parameter}}
+  friend U operator ""_a(const T *, size_t); // expected-error {{parameter}}
 };
 template<char...> struct V {
-  friend void operator "" _b(); // expected-error {{parameters}}
+  friend void operator ""_b(); // expected-error {{parameters}}
 };
 
-template<char... C, int N = 0> void operator "" _b(); // expected-error {{template}}
-template<char... C> void operator "" _b(int N = 0); // expected-error {{template}}
-template<char, char...> void operator "" _b(); // expected-error {{template}}
-template<typename T> T operator "" _b(const char *); // expected-error {{template}}
-template<typename T> int operator "" _b(const T *, size_t); // expected-error {{template}}
+template<char... C, int N = 0> void operator ""_b(); // expected-error {{template}}
+template<char... C> void operator ""_b(int N = 0); // expected-error {{template}}
+template<char, char...> void operator ""_b(); // expected-error {{template}}
+template<typename T> T operator ""_b(const char *); // expected-error {{template}}
+template<typename T> int operator ""_b(const T *, size_t); // expected-error {{template}}

clang/test/CXX/over/over.oper/over.literal/p6.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 // expected-note@+1 {{extern "C" language linkage specification begins here}}
-extern "C" void operator "" _a(const char *); // expected-error {{must have C++ linkage}}
-extern "C" template<char...> void operator "" _b(); // expected-error {{must have C++ linkage}}
+extern "C" void operator ""_a(const char *); // expected-error {{must have C++ linkage}}
+extern "C" template<char...> void operator ""_b(); // expected-error {{must have C++ linkage}}
 // expected-note@-1 {{extern "C" language linkage specification begins here}}
 
 extern "C" { // expected-note 4 {{extern "C" language linkage specification begins here}}
-  void operator "" _c(const char *); // expected-error {{must have C++ linkage}}
-  template<char...> void operator "" _d(); // expected-error {{must have C++ linkage}}
+  void operator ""_c(const char *); // expected-error {{must have C++ linkage}}
+  template<char...> void operator ""_d(); // expected-error {{must have C++ linkage}}
   namespace N {
-    void operator "" _e(const char *); // expected-error {{must have C++ linkage}}
-    template<char...> void operator "" _f(); // expected-error {{must have C++ linkage}}
+    void operator ""_e(const char *); // expected-error {{must have C++ linkage}}
+    template<char...> void operator ""_f(); // expected-error {{must have C++ linkage}}
   }
 }

clang/test/CXX/over/over.oper/over.literal/p7.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 // expected-no-diagnostics
 
-constexpr int operator "" _a(const char *c) {
+constexpr int operator ""_a(const char *c) {
   return c[0];
 }
 
-static_assert(operator "" _a("foo") == 'f', "");
+static_assert(operator ""_a("foo") == 'f', "");
 
 void puts(const char *);
-static inline void operator "" _puts(const char *c) {
+static inline void operator ""_puts(const char *c) {
   puts(c);
 }
 void f() {
-  operator "" _puts("foo");
-  operator "" _puts("bar");
+  operator ""_puts("foo");
+  operator ""_puts("bar");
 }

clang/test/CXX/over/over.oper/over.literal/p8.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 struct string;
 namespace std {
   using size_t = decltype(sizeof(int));
 }
 
-void operator "" _km(long double); // ok
-string operator "" _i18n(const char*, std::size_t); // ok
-template<char...> int operator "" \u03C0(); // ok, UCN for lowercase pi // expected-warning {{reserved}}
-float operator ""E(const char *); // expected-error {{invalid suffix on literal}} expected-warning {{reserved}}
-float operator " " B(const char *); // expected-error {{must be '""'}} expected-warning {{reserved}}
+void operator ""_km(long double); // ok
+string operator ""_i18n(const char*, std::size_t); // ok
+template<char...> int operator ""\u03C0(); // ok, UCN for lowercase pi // expected-warning {{reserved}}
+float operator ""E(const char *); // expected-warning {{reserved}}
+float operator " "B(const char *); // expected-error {{must be '""'}} expected-warning {{reserved}}
 string operator "" 5X(const char *, std::size_t); // expected-error {{expected identifier}}
-double operator "" _miles(double); // expected-error {{parameter}}
-template<char...> int operator "" j(const char*); // expected-error {{template}}
+double operator ""_miles(double); // expected-error {{parameter}}
+template<char...> int operator ""j(const char*); // expected-error {{template}}
 
 float operator ""_E(const char *);

clang/test/CodeGenCXX/cxx11-user-defined-literal.cpp

 // RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s
 
 struct S { S(); ~S(); S(const S &); void operator()(int); };
 using size_t = decltype(sizeof(int));
-S operator"" _x(const char *, size_t);
-S operator"" _y(wchar_t);
-S operator"" _z(unsigned long long);
-S operator"" _f(long double);
-S operator"" _r(const char *);
-template<char...Cs> S operator"" _t() { return S(); }
+S operator""_x(const char *, size_t);
+S operator""_y(wchar_t);
+S operator""_z(unsigned long long);
+S operator""_f(long double);
+S operator""_r(const char *);
+template<char...Cs> S operator""_t() { return S(); }
 
 // CHECK: @[[s_foo:.*]] = {{.*}} constant [4 x i8] c"foo\00"
 // CHECK: @[[s_bar:.*]] = {{.*}} constant [4 x i8] c"bar\00"
 // CHECK: @[[s_123:.*]] = {{.*}} constant [4 x i8] c"123\00"
 // CHECK: @[[s_4_9:.*]] = {{.*}} constant [4 x i8] c"4.9\00"
 // CHECK: @[[s_0xffffeeee:.*]] = {{.*}} constant [11 x i8] c"0xffffeeee\00"
 
 void f() {
eeee_r;
   // CHECK: call void @_Zli2_tIJLc48ELc120ELc49ELc50ELc51ELc52ELc53ELc54ELc55ELc56EEE1Sv({{.*}})
   // CHECK: call void @_ZN1SD1Ev({{.*}})
   0x12345678_t;
 }
 
 // CHECK: define {{.*}} @_Zli2_tIJLc48ELc120ELc49ELc50ELc51ELc52ELc53ELc54ELc55ELc56EEE1Sv(
 
 template<typename T> auto g(T t) -> decltype("foo"_x(t)) { return "foo"_x(t); }
-template<typename T> auto i(T t) -> decltype(operator"" _x("foo", 3)(t)) { return operator"" _x("foo", 3)(t); }
+template<typename T> auto i(T t) -> decltype(operator""_x("foo", 3)(t)) { return operator""_x("foo", 3)(t); }
 
 void h() {
   g(42);
   i(42);
 }
 
 // CHECK: define {{.*}} @_Z1hv()
 // CHECK:   call void @_Z1gIiEDTclclL_Zli2_xPKcmELA4_S0_ELm3EEfp_EET_(i32 noundef 42)

clang/test/CodeGenCXX/mangle-ms-cxx11.cpp

struct A {
   void foo() __restrict &&;
 };
 void A::foo() __restrict & {}
 // CHECK-DAG: @"?foo@A@PR19361@@QIGAEXXZ"
 void A::foo() __restrict && {}
 // CHECK-DAG: @"?foo@A@PR19361@@QIHAEXXZ"
 }
 
-int operator"" _deg(long double) { return 0; }
+int operator""_deg(long double) { return 0; }
 // CHECK-DAG: @"??__K_deg@@YAHO@Z"
 
 template <char...>
 void templ_fun_with_pack() {}
 
 template void templ_fun_with_pack<>();
 // CHECK-DAG: @"??$templ_fun_with_pack@$S@@YAXXZ"
 

clang/test/FixIt/fixit-c++11.cpp

-// RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens %s
+// RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens -Wno-deprecated-literal-operator %s
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -x c++ -std=c++11 -fixit %t
 // RUN: %clang_cc1 -Wall -pedantic -x c++ -std=c++11 %t
 
 /* This is a test of the various code modification hints that only
    apply in C++0x. */
 struct A {
   explicit operator int(); // expected-note{{conversion to integral type}}
#if __cplusplus <= 202002L
   // expected-warning@-3{{is a C++23 extension}}
 #endif
 
   delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
   delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
 }
 
 #define bar "bar"
-const char *p = "foo"bar; // expected-error {{requires a space between}}
+const char *p = "foo" bar;
 #define ord - '0'
-int k = '4'ord; // expected-error {{requires a space between}}
+int k = '4' ord;
 
 void operator"x" _y(char); // expected-error {{must be '""'}}
 void operator L"" _z(char); // expected-error {{encoding prefix}}
 void operator "x" "y" U"z" ""_whoops "z" "y"(char); // expected-error {{must be '""'}}
 
 void f() {
   'b'_y;
   'c'_z;

clang/test/OpenMP/amdgcn_ldbl_check.cpp

 // REQUIRES: amdgpu-registered-target
 
 // RUN: %clang_cc1 -triple x86_64-mingw64 -emit-llvm-bc -target-cpu x86-64 -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -o %t.bc -x c++ %s
 // RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -aux-triple x86_64-mingw64 -fsyntax-only -target-cpu gfx900 -fopenmp -fopenmp-is-target-device -fopenmp-host-ir-file-path %t.bc -x c++ %s
 // expected-no-diagnostics
 
 void print(double);
 
-constexpr double operator"" _X (long double a)
+constexpr double operator""_X (long double a)
 {
   return (double)a;
 }
 
 int main()
 {
   auto a = 1._X;
   print(a);

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

 // RUN: %clang_cc1 -pedantic-errors -std=c++11 -emit-pch %s -o %t
 // RUN: %clang_cc1 -pedantic-errors -std=c++11 -include-pch %t -verify %s
 
 // RUN: %clang_cc1 -pedantic-errors -std=c++11 -emit-pch -fpch-instantiate-templates %s -o %t
 // RUN: %clang_cc1 -pedantic-errors -std=c++11 -include-pch %t -verify %s
 
 #ifndef HEADER_INCLUDED
 
 #define HEADER_INCLUDED
 
 using size_t = decltype(sizeof(int));
-int operator"" _foo(const char *p, size_t);
+int operator""_foo(const char *p, size_t);
 
 template<typename T> auto f(T t) -> decltype(t + ""_foo) { return 0; }
 
 #else
 
 int j = ""_foo;
 int k = f(0);
 int *l = f(&k);
 struct S {};
 int m = f(S()); // expected-error {{no matching}}
                 // expected-note@14 {{substitution failure}}
 
 #endif

clang/test/Parser/cxx0x-literal-operators.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 void operator "" (const char *); // expected-error {{expected identifier}}
-void operator "k" foo(const char *); // \
+void operator "k"foo(const char *); // \
   expected-error {{string literal after 'operator' must be '""'}} \
   expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
-void operator "" tester (const char *); // \
+void operator ""tester (const char *); // \
   expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}

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

 
 // A ud-suffix cannot be used on integer literals in preprocessor constant
 // expressions:
 #if 0_foo // expected-error {{integer literal with user-defined suffix cannot be used in preprocessor constant expression}}
 #error error
 #endif
 
 // But they can appear in expressions.
-constexpr char operator"" _id(char c) { return c; }
-constexpr wchar_t operator"" _id(wchar_t c) { return c; }
-constexpr char16_t operator"" _id(char16_t c) { return c; }
-constexpr char32_t operator"" _id(char32_t c) { return c; }
+constexpr char operator""_id(char c) { return c; }
+constexpr wchar_t operator""_id(wchar_t c) { return c; }
+constexpr char16_t operator""_id(char16_t c) { return c; }
+constexpr char32_t operator""_id(char32_t c) { return c; }
 
 using size_t = decltype(sizeof(int));
-constexpr const char operator"" _id(const char *p, size_t n) { return *p; }
-constexpr const wchar_t operator"" _id(const wchar_t *p, size_t n) { return *p; }
-constexpr const char16_t operator"" _id(const char16_t *p, size_t n) { return *p; }
-constexpr const char32_t operator"" _id(const char32_t *p, size_t n) { return *p; }
+constexpr const char operator""_id(const char *p, size_t n) { return *p; }
+constexpr const wchar_t operator""_id(const wchar_t *p, size_t n) { return *p; }
+constexpr const char16_t operator""_id(const char16_t *p, size_t n) { return *p; }
+constexpr const char32_t operator""_id(const char32_t *p, size_t n) { return *p; }
 
-constexpr unsigned long long operator"" _id(unsigned long long n) { return n; }
-constexpr long double operator"" _id(long double d) { return d; }
+constexpr unsigned long long operator""_id(unsigned long long n) { return n; }
+constexpr long double operator""_id(long double d) { return d; }
 
 template<int n> struct S {};
 S<"a"_id> sa;
 S<L"b"_id> sb;
 S<u8"c"_id> sc;
 S<u"d"_id> sd;
 S<U"e"_id> se;
 

 
 int k =
 1234567.89\
 _no_such_suffix; // expected-error {{'operator""_no_such_suffix'}}
 
 // Make sure we handle more interesting ways of writing a string literal which
 // is "" in translation phase 7.
 void operator "\
-" _foo(unsigned long long); // ok
+"_foo(unsigned long long); // ok
 
-void operator R"xyzzy()xyzzy" _foo(long double); // ok
+void operator R"xyzzy()xyzzy"_foo(long double); // ok
 
-void operator"" "" R"()" "" _foo(const char *); // ok
+void operator"" "" R"()" ""_foo(const char *); // ok
 
 void operator ""_no_space(const char *); // ok
 
 // Ensure we diagnose the bad cases.
-void operator "\0" _non_empty(const char *); // expected-error {{must be '""'}}
-void operator L"" _not_char(const char *); // expected-error {{cannot have an encoding prefix}}
+void operator "\0"_non_empty(const char *); // expected-error {{must be '""'}}
+void operator L""_not_char(const char *); // expected-error {{cannot have an encoding prefix}}
 void operator "" ""
 U"" // expected-error {{cannot have an encoding prefix}}
-"" _also_not_char(const char *);
+""_also_not_char(const char *);
 void operator "" u8"" "\u0123" "hello"_all_of_the_things ""(const char*); // expected-error {{must be '""'}}
 
 // Make sure we treat UCNs and UTF-8 as equivalent.
 int operator""_µs(unsigned long long) {} // expected-note {{previous}}
 int hundred_µs = 50_µs + 50_\u00b5s;
 int operator""_\u00b5s(unsigned long long) {} // expected-error {{redefinition of 'operator""_µs'}}
 
 int operator""_\U0000212B(long double) {} // expected-note {{previous}}

clang/test/SemaCXX/cxx11-ast-print.cpp

 // RUN: %clang_cc1 -std=c++11 -ast-print %s | FileCheck %s
 
 // CHECK: auto operator""_foo(const char *p, decltype(sizeof(int))) -> decltype(nullptr);
-auto operator"" _foo(const char *p, decltype(sizeof(int))) -> decltype(nullptr);
+auto operator""_foo(const char *p, decltype(sizeof(int))) -> decltype(nullptr);
 
 // CHECK: decltype(""_foo) operator""_bar(unsigned long long);
-decltype(""_foo) operator"" _bar(unsigned long long);
+decltype(""_foo) operator""_bar(unsigned long long);
 
 // CHECK: decltype(42_bar) operator""_baz(long double);
-decltype(42_bar) operator"" _baz(long double);
+decltype(42_bar) operator""_baz(long double);
 
 // CHECK: decltype(4.5_baz) operator""_baz(char);
-decltype(4.5_baz) operator"" _baz(char);
+decltype(4.5_baz) operator""_baz(char);
 
 // CHECK: const char *operator""_quux(const char *);
-const char *operator"" _quux(const char *);
+const char *operator""_quux(const char *);
 
 // CHECK: template <char ...> const char *operator""_fritz();
-template<char...> const char *operator"" _fritz();
+template<char...> const char *operator""_fritz();
 
 // CHECK: const char *p1 = "bar1"_foo;
 const char *p1 = "bar1"_foo;
 // CHECK: const char *p2 = "bar2"_foo;
 const char *p2 = R"x(bar2)x"_foo;
 // CHECK: const char *p3 = u8"bar3"_foo;
 const char *p3 = u8"bar3"_foo;
 // CHECK: const char *p4 = 297_bar;
 const char *p4 = 0x129_bar;
 // CHECK: const char *p5 = 1.0E+12_baz;
 const char *p5 = 1e12_baz;
 // CHECK: const char *p6 = 'x'_baz;
 const char *p6 = 'x'_baz;
 // CHECK: const char *p7 = 123_quux;
 const char *p7 = 123_quux;
 // CHECK: const char *p8 = 4.9_quux;
 const char *p8 = 4.9_quux;
 // CHECK: const char *p9 = 0x42e3F_fritz;
 const char *p9 = 0x42e3F_fritz;
 // CHECK: const char *p10 = 3.300e+15_fritz;
 const char *p10 = 3.300e+15_fritz;
 
-template <class C, C...> const char *operator"" _suffix();
+template <class C, C...> const char *operator""_suffix();
 // CHECK: const char *PR23120 = operator""_suffix<char32_t, U'\U00010437'>();
 const char *PR23120 = U"𐐷"_suffix;
 
 // PR28885
 struct A {
   A();
 };
 struct B : A {

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

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wunused
 
 namespace {
-double operator"" _x(long double value) { return double(value); }
-int operator"" _ii(long double value) { return int(value); } // expected-warning {{not needed and will not be emitted}}
+double operator""_x(long double value) { return double(value); }
+int operator""_ii(long double value) { return int(value); } // expected-warning {{not needed and will not be emitted}}
 }
 
 namespace rdar13589856 {
   template<class T> double value() { return 3.2_x; }
   template<class T> int valuei() { return 3.2_ii; }
 
   double get_value() { return value<double>(); }
 }

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

 // RUN: %clang_cc1 -std=c++11 -verify %s -fms-extensions -triple x86_64-apple-darwin9.0.0
 
 using size_t = decltype(sizeof(int));
 enum class LitKind {
   Char, WideChar, Char16, Char32,
   CharStr, WideStr, Char16Str, Char32Str,
   Integer, Floating, Raw, Template
 };
-constexpr LitKind operator"" _kind(char p) { return LitKind::Char; }
-constexpr LitKind operator"" _kind(wchar_t p) { return LitKind::WideChar; }
-constexpr LitKind operator"" _kind(char16_t p) { return LitKind::Char16; }
-constexpr LitKind operator"" _kind(char32_t p) { return LitKind::Char32; }
-constexpr LitKind operator"" _kind(const char *p, size_t n) { return LitKind::CharStr; }
-constexpr LitKind operator"" _kind(const wchar_t *p, size_t n) { return LitKind::WideStr; }
-constexpr LitKind operator"" _kind(const char16_t *p, size_t n) { return LitKind::Char16Str; }
-constexpr LitKind operator"" _kind(const char32_t *p, size_t n) { return LitKind::Char32Str; }
-constexpr LitKind operator"" _kind(unsigned long long n) { return LitKind::Integer; }
-constexpr LitKind operator"" _kind(long double n) { return LitKind::Floating; }
-constexpr LitKind operator"" _kind2(const char *p) { return LitKind::Raw; }
-template<char ...Cs> constexpr LitKind operator"" _kind3() { return LitKind::Template; }
+constexpr LitKind operator""_kind(char p) { return LitKind::Char; }
+constexpr LitKind operator""_kind(wchar_t p) { return LitKind::WideChar; }
+constexpr LitKind operator""_kind(char16_t p) { return LitKind::Char16; }
+constexpr LitKind operator""_kind(char32_t p) { return LitKind::Char32; }
+constexpr LitKind operator""_kind(const char *p, size_t n) { return LitKind::CharStr; }
+constexpr LitKind operator""_kind(const wchar_t *p, size_t n) { return LitKind::WideStr; }
+constexpr LitKind operator""_kind(const char16_t *p, size_t n) { return LitKind::Char16Str; }
+constexpr LitKind operator""_kind(const char32_t *p, size_t n) { return LitKind::Char32Str; }
+constexpr LitKind operator""_kind(unsigned long long n) { return LitKind::Integer; }
+constexpr LitKind operator""_kind(long double n) { return LitKind::Floating; }
+constexpr LitKind operator""_kind2(const char *p) { return LitKind::Raw; }
+template<char ...Cs> constexpr LitKind operator""_kind3() { return LitKind::Template; }
 
 static_assert('x'_kind == LitKind::Char, "");
 static_assert(L'x'_kind == LitKind::WideChar, "");
 static_assert(u'x'_kind == LitKind::Char16, "");
 static_assert(U'x'_kind == LitKind::Char32, "");
 static_assert("foo"_kind == LitKind::CharStr, "");
 static_assert(u8"foo"_kind == LitKind::CharStr, "");
 static_assert(L"foo"_kind == LitKind::WideStr, "");
 static_assert(u"foo"_kind == LitKind::Char16Str, "");
 static_assert(U"foo"_kind == LitKind::Char32Str, "");
 static_assert(194_kind == LitKind::Integer, "");
 static_assert(0377_kind == LitKind::Integer, "");
 static_assert(0x5ffc_kind == LitKind::Integer, "");
 static_assert(.5954_kind == LitKind::Floating, "");
 static_assert(1._kind == LitKind::Floating, "");
 static_assert(1.e-2_kind == LitKind::Floating, "");
 static_assert(4e6_kind == LitKind::Floating, "");
 static_assert(4e6_kind2 == LitKind::Raw, "");
 static_assert(4e6_kind3 == LitKind::Template, "");
 
 constexpr const char *fractional_digits_impl(const char *p) {
   return *p == '.' ? p + 1 : *p ? fractional_digits_impl(p + 1) : 0;
 }
-constexpr const char *operator"" _fractional_digits(const char *p) {
+constexpr const char *operator""_fractional_digits(const char *p) {
   return fractional_digits_impl(p) ?: p;
 }
 constexpr bool streq(const char *p, const char *q) {
   return *p == *q && (!*p || streq(p+1, q+1));
 }
 
 static_assert(streq(143.97_fractional_digits, "97"), "");
 static_assert(streq(0x786_fractional_digits, "0x786"), "");
 static_assert(streq(.4_fractional_digits, "4"), "");
 static_assert(streq(4._fractional_digits, ""), "");
 static_assert(streq(1e+97_fractional_digits, "1e+97"), "");
 static_assert(streq(0377_fractional_digits, "0377"), "");
 static_assert(streq(0377.5_fractional_digits, "5"), "");
 
-int operator"" _ambiguous(char); // expected-note {{candidate}}
+int operator""_ambiguous(char); // expected-note {{candidate}}
 namespace N {
-  void *operator"" _ambiguous(char); // expected-note {{candidate}}
+  void *operator""_ambiguous(char); // expected-note {{candidate}}
 }
 using namespace N;
 int k = 'x'_ambiguous; // expected-error {{ambiguous}}
 
-int operator"" _deleted(unsigned long long) = delete; // expected-note {{here}}
+int operator""_deleted(unsigned long long) = delete; // expected-note {{here}}
 int m = 42_deleted; // expected-error {{attempt to use a deleted}}
 
 namespace Using {
   namespace M {
-    int operator"" _using(char);
+    int operator""_using(char);
   }
   int k1 = 'x'_using; // expected-error {{no matching literal operator for call to 'operator""_using'}}
 
-  using M::operator "" _using;
+  using M::operator ""_using;
   int k2 = 'x'_using;
 }
 
 namespace AmbiguousRawTemplate {
-  int operator"" _ambig1(const char *); // expected-note {{candidate}}
-  template<char...> int operator"" _ambig1(); // expected-note {{candidate}}
+  int operator""_ambig1(const char *); // expected-note {{candidate}}
+  template<char...> int operator""_ambig1(); // expected-note {{candidate}}
 
   int k1 = 123_ambig1; // expected-error {{call to 'operator""_ambig1' is ambiguous}}
 
   namespace Inner {
-    template<char...> int operator"" _ambig2(); // expected-note 3{{candidate}}
+    template<char...> int operator""_ambig2(); // expected-note 3{{candidate}}
   }
-  int operator"" _ambig2(const char *); // expected-note 3{{candidate}}
-  using Inner::operator"" _ambig2;
+  int operator""_ambig2(const char *); // expected-note 3{{candidate}}
+  using Inner::operator""_ambig2;
 
   int k2 = 123_ambig2; // expected-error {{call to 'operator""_ambig2' is ambiguous}}
 
   namespace N {
-    using Inner::operator"" _ambig2;
+    using Inner::operator""_ambig2;
 
     int k3 = 123_ambig2; // ok
 
-    using AmbiguousRawTemplate::operator"" _ambig2;
+    using AmbiguousRawTemplate::operator""_ambig2;
 
     int k4 = 123_ambig2; // expected-error {{ambiguous}}
 
     namespace M {
 
-      template<char...> int operator"" _ambig2();
+      template<char...> int operator""_ambig2();
 
       int k5 = 123_ambig2; // ok
     }
 
-    int operator"" _ambig2(unsigned long long);
+    int operator""_ambig2(unsigned long long);
 
     int k6 = 123_ambig2; // ok
     int k7 = 123._ambig2; // expected-error {{ambiguous}}
   }
 }
 
 constexpr unsigned mash(unsigned a) {
  return 0x93ae27b5 * ((a >> 13) | a << 19);
 }
 template<typename=void> constexpr unsigned hash(unsigned a) { return a; }
 template<char C, char...Cs> constexpr unsigned hash(unsigned a) {
  return hash<Cs...>(mash(a ^ mash(C)));
 }
 template<typename T, T v> struct constant { constexpr static T value = v; };
-template<char...Cs> constexpr unsigned operator"" _hash() {
+template<char...Cs> constexpr unsigned operator""_hash() {
   return constant<unsigned, hash<Cs...>(0)>::value;
 }
 static_assert(0x1234_hash == 0x103eff5e, "");
 static_assert(hash<'0', 'x', '1', '2', '3', '4'>(0) == 0x103eff5e, "");
 
 // Functions and literal suffixes go in separate namespaces.
 namespace Namespace {
-  template<char...> int operator"" _x();
+  template<char...> int operator""_x();
   int k = _x(); // expected-error {{undeclared identifier '_x'}}
 
   int _y(unsigned long long);
   int k2 = 123_y; // expected-error {{no matching literal operator for call to 'operator""_y'}}
 }
 
 namespace PR14950 {
   template<...> // expected-error {{expected template parameter}}
-  int operator"" _b(); // expected-error {{no function template matches function template specialization}}
+  int operator""_b(); // expected-error {{no function template matches function template specialization}}
   int main() { return 0_b; } // expected-error {{no matching literal operator for call to 'operator""_b'}}
 }
 
 namespace bad_names {
   template<char...> int operator""_x();
 
   template<typename T> void f() {
     class T:: // expected-error {{anonymous class}} expected-warning {{does not declare anything}}

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

namespace std {
   complex<long double> operator""il(unsigned long long);
 }
 
 #else
 
 using namespace std;
 duration a = 1ns, b = 1us, c = 1ms, d = 1s, e = 1min, f = 1h;
 string s = "foo"s;
-char error = 'x's; // expected-error {{invalid suffix}} expected-error {{expected ';'}}
+char error = 'x's; // expected-error {{no matching literal operator for call to 'operator""s' with argument of type 'char'}}
 
 int _1y = 1y; // expected-error {{invalid suffix}}
 int _1b = 1b; // expected-error {{invalid digit}}
 
 complex<float> cf1 = 1if, cf2 = 2.if, cf3 = 0x3if;
 complex<double> cd1 = 1i, cd2 = 2.i, cd3 = 0b0110101i;
 complex<long double> cld1 = 1il, cld2 = 2.il, cld3 = 0047il;
 
 #endif

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

namespace std {
   string_view operator""sv(const char*, size_t);
 }
 
 #else
 
 using namespace std;
 string_view s = "foo"sv;
 const char* p = "bar"sv; // expected-error {{no viable conversion}}
-char error = 'x'sv; // expected-error {{invalid suffix}} expected-error {{expected ';'}}
+char error = 'x'sv; // expected-error {{no matching literal operator for call to 'operator""sv' with argument of type 'char'}}
 
 #endif

clang/test/SemaCXX/cxx2a-consteval.cpp

 int i2 = f1(&f1, &f1, &f1, &f1, &f1, &f1, &f1);
 
 int i3 = f1(f1(f1(&f1, &f1), f1(&f1, &f1), f1(f1(&f1, &f1), &f1)));
 
 }
 
 namespace user_defined_literal {
 
-consteval int operator"" _test(unsigned long long i) {
+consteval int operator""_test(unsigned long long i) {
 // expected-note@-1+ {{declared here}}
   return 0;
 }
 
 int i = 0_test;
 
-auto ptr = &operator"" _test;
+auto ptr = &operator""_test;
 // expected-error@-1 {{take address}}
 
-consteval auto operator"" _test1(unsigned long long i) {
+consteval auto operator""_test1(unsigned long long i) {
   return &f_eval;
 }
 
 auto i1 = 0_test1; // expected-error {{is not a constant expression}}
 // expected-note@-1 {{is not a constant expression}}
 
 }
 

clang/test/SemaCXX/cxx98-compat.cpp

int InitList(int i = {}) { // expected-warning {{generalized initializer lists are incompatible with C++98}} \
   struct { int a; const int &r; } rr = { 0, {0} }; // expected-warning {{reference initialized from initializer list is incompatible with C++98}}
   return { 0 }; // expected-warning {{generalized initializer lists are incompatible with C++98}} expected-warning {{scalar}}
 }
 struct DelayedDefaultArgumentParseInitList {
   void f(int i = {1}) { // expected-warning {{generalized initializer lists are incompatible with C++98}} expected-warning {{scalar}}
   }
 };
 
-int operator"" _hello(const char *); // expected-warning {{literal operators are incompatible with C++98}}
+int operator""_hello(const char *); // expected-warning {{literal operators are incompatible with C++98}}
 
 enum EnumFixed : int { // expected-warning {{enumeration types with a fixed underlying type are incompatible with C++98}}
 };
 
 enum class EnumScoped { // expected-warning {{scoped enumerations are incompatible with C++98}}
 };
 
 void Deleted() = delete; // expected-warning {{deleted function definitions are incompatible with C++98}}

clang/test/SemaCXX/literal-operators.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 
 #include <stddef.h>
 
 struct tag {
-  void operator "" _tag_bad (const char *); // expected-error {{literal operator 'operator""_tag_bad' must be in a namespace or global scope}}
-  friend void operator "" _tag_good (const char *);
+  void operator ""_tag_bad (const char *); // expected-error {{literal operator 'operator""_tag_bad' must be in a namespace or global scope}}
+  friend void operator ""_tag_good (const char *);
 };
 
-namespace ns { void operator "" _ns_good (const char *); }
+namespace ns { void operator ""_ns_good (const char *); }
 
 // Check extern "C++" declarations
-extern "C++" void operator "" _extern_good (const char *);
-extern "C++" { void operator "" _extern_good (const char *); }
+extern "C++" void operator ""_extern_good (const char *);
+extern "C++" { void operator ""_extern_good (const char *); }
 
-void fn () { void operator "" _fn_good (const char *); }
+void fn () { void operator ""_fn_good (const char *); }
 
 // One-param declarations (const char * was already checked)
-void operator "" _good (char);
-void operator "" _good (wchar_t);
-void operator "" _good (char16_t);
-void operator "" _good (char32_t);
-void operator "" _good (unsigned long long);
-void operator "" _good (long double);
+void operator ""_good (char);
+void operator ""_good (wchar_t);
+void operator ""_good (char16_t);
+void operator ""_good (char32_t);
+void operator ""_good (unsigned long long);
+void operator ""_good (long double);
 
 // Two-param declarations
-void operator "" _good (const char *, size_t);
-void operator "" _good (const wchar_t *, size_t);
-void operator "" _good (const char16_t *, size_t);
-void operator "" _good (const char32_t *, size_t);
+void operator ""_good (const char *, size_t);
+void operator ""_good (const wchar_t *, size_t);
+void operator ""_good (const char16_t *, size_t);
+void operator ""_good (const char32_t *, size_t);
 
 // Check typedef and array equivalences
-void operator "" _good (const char[]);
+void operator ""_good (const char[]);
 typedef const char c;
-void operator "" _good (c*);
+void operator ""_good (c*);
 
 // Check extra cv-qualifiers
-void operator "" _cv_good (volatile const char *, const size_t); // expected-error {{invalid literal operator parameter type 'const volatile char *', did you mean 'const char *'?}}
+void operator ""_cv_good (volatile const char *, const size_t); // expected-error {{invalid literal operator parameter type 'const volatile char *', did you mean 'const char *'?}}
 
 // Template declaration
-template <char...> void operator "" _good ();
+template <char...> void operator ""_good ();
 
-template <typename...> void operator "" _invalid(); // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
-template <wchar_t...> void operator "" _invalid();  // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
-template <unsigned long long...> void operator "" _invalid();  // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
+template <typename...> void operator ""_invalid(); // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
+template <wchar_t...> void operator ""_invalid();  // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
+template <unsigned long long...> void operator ""_invalid();  // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
 
 _Complex float operator""if(long double); // expected-warning {{reserved}}
 _Complex float test_if_1() { return 2.0f + 1.5if; };
 void test_if_2() { "foo"if; } // expected-error {{no matching literal operator for call to 'operator""if'}}
 
 template<typename T> void dependent_member_template() {
   T().template operator""_foo<int>(); // expected-error {{'operator""_foo' following the 'template' keyword cannot refer to a dependent template}}
 }
 
 namespace PR51142 {
 // This code previously crashed due to a null template parameter declaration.
 template<typename T> // expected-error {{template parameter list for literal operator must be either 'char...' or 'typename T, T...'}}
 constexpr auto operator ""_l();
 }

clang/test/SemaCXX/no-warn-user-defined-literals-in-system-headers.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wsystem-headers -isystem %S %s
 
 #include <no-warn-user-defined-literals-in-system-headers.h>
 
-void operator "" bar(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}
+void operator ""bar(long double); // expected-warning{{user-defined literal suffixes not starting with '_' are reserved}}

clang/test/SemaCXX/reserved-identifier.cpp

 
 long double operator""_SacreBleu(long double) // no-warning
 {
   return 0.;
 }
 
 long double sacrebleu = operator"" _SacreBleu(1.2); // expected-warning {{identifier '_SacreBleu' is reserved because it starts with '_' followed by a capital letter}}
 long double sangbleu = operator""_SacreBleu(1.2);   // no-warning
 
-void operator"" _lowercase(unsigned long long); // no-warning
-void operator""_lowercase(unsigned long long); // no-warning
+void operator""_lowercase(unsigned long long); // no-warning
 
 struct _BarbeRouge { // expected-warning {{identifier '_BarbeRouge' is reserved because it starts with '_' followed by a capital letter}}
 } p;
 struct _BarbeNoire { // expected-warning {{identifier '_BarbeNoire' is reserved because it starts with '_' followed by a capital letter}}
 } * q;
 
 struct Any {
   friend void _barbegrise(); // expected-warning {{identifier '_barbegrise' is reserved because it starts with '_' at global scope}}

clang/test/SemaCXX/warn-xor-as-pow.cpp

 #define TWO_ULL 2ULL
 #define EPSILON 10 ^ -300
 #define ALPHA_OFFSET 3
 #define EXP 3
 
 #define flexor 7
 
 #ifdef __cplusplus
-constexpr long long operator"" _xor(unsigned long long v) { return v; }
+constexpr long long operator""_xor(unsigned long long v) { return v; }
 
-constexpr long long operator"" _0b(unsigned long long v) { return v; }
-constexpr long long operator"" _0X(unsigned long long v) { return v; }
+constexpr long long operator""_0b(unsigned long long v) { return v; }
+constexpr long long operator""_0X(unsigned long long v) { return v; }
 #else
 #define xor ^ // iso646.h
 #endif
 
 void test(unsigned a, unsigned b) {
   unsigned res;
   res = a ^ 5;
   res = 2 ^ b;

clang/www/cxx_dr_status.html

<tr id="1472">
     <td>CD3</td>
     <td>odr-use of reference variables</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1473">
     <td><a href="https://cplusplus.github.io/CWG/issues/1473.html">1473</a></td>
     <td>CD3</td>
     <td>Syntax of <I>literal-operator-id</I></td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 18</td>
   </tr>
   <tr id="1474">
     <td><a href="https://cplusplus.github.io/CWG/issues/1474.html">1474</a></td>
     <td>NAD</td>
     <td>User-defined literals and <TT>&lt;inttypes.h&gt;</TT> format macros</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="1475">