Support Unicode Microsoft predefined macros

[RIscRIpt]

This implementation preserves support for identifiers L__FUNCSIG__ and L__FUNCTION__ (which have never been supported by MSVC), and adds other identifiers for all supported encodings: L, u8, u, U.

If breaking backwards compatibility in clang (with Microsoft Extensions) is allowed, then I'd prefer other (more correct) solution: support for __LPREFIX-family macros ( see https://godbolt.org/z/eacYqh1ab ), and remove token/identifiers like L__FUNCTION__; relevant issue https://github.com/llvm/llvm-project/issues/27402
I'll try to implement this alternative approach.

[cor3ntin]

This does not appear to be valid under MSVC and I don't think we should support features that MS does not (Nor can i find any documentation that it ought to work)
https://godbolt.org/z/7Te3YYeb9

Supporting the same concatenation behavior MSVC does have seem like a cleaner approach. We would not have an many new tokens.
Before you do anything though. I'd like the feedback of more folks.

I can't find any documentation for LPREFIX, but it seems in the general case, it can be emulated that way https://godbolt.org/z/dr7MjMs99

In terms of breaking change, it's only an issue if L/u/etc are existing macro at the point of use.

[aaron.ballman]

In D157747#4581933, @cor3ntin wrote:

This does not appear to be valid under MSVC and I don't think we should support features that MS does not (Nor can i find any documentation that it ought to work)
https://godbolt.org/z/7Te3YYeb9

Agreed -- we typically do not want to make extensions to Microsoft's extensions.

Supporting the same concatenation behavior MSVC does have seem like a cleaner approach. We would not have an many new tokens.
Before you do anything though. I'd like the feedback of more folks.

I can't find any documentation for LPREFIX, but it seems in the general case, it can be emulated that way https://godbolt.org/z/dr7MjMs99

In terms of breaking change, it's only an issue if L/u/etc are existing macro at the point of use.

It's a bit hard to reason about __LPREFIX given there's no documentation for it and it's not a macro that expands to anything we can poke at. However, https://github.com/llvm/llvm-project/issues/27402 shows there is interest in having Clang support it, so I weakly lean towards that option, though it may be more effort to reverse engineer how it works for various edge cases.

[RIscRIpt]

While I work at __LPREFIX, I remove this revision from review queue.

[RIscRIpt]

I found a way to implement __LPREFIX-macros-family in Clang. I need some more time to finish and polish it. Going to post it a couple of weeks later.

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.cpp

if (SuppressMacroExpansions.find(ER.getAsRange()) !=
       // This is a macro expansion for which we should not warn.
       return;
     }
   }
   diag(E->getLocation(),
        "inside a lambda, '%0' expands to the name of the function call "
        "operator; consider capturing the name of the enclosing function "
        "explicitly")
-      << PredefinedExpr::getIdentKindName(E->getIdentKind());
+      << E->getIdentKindName();
 }
 
 } // namespace clang::tidy::bugprone

clang/include/clang/AST/Expr.h

class PredefinedExpr final
   // PredefinedExpr is optionally followed by a single trailing
   // "Stmt *" for the predefined identifier. It is present if and only if
   // hasFunctionName() is true and is always a "StringLiteral *".
 
 public:
   enum IdentKind {
     Func,
     Function,
-    LFunction, // Same as Function, but as wide string.
     FuncDName,
     FuncSig,
-    LFuncSig, // Same as FuncSig, but as wide string
     PrettyFunction,
     /// The same as PrettyFunction, except that the
     /// 'virtual' keyword is omitted for virtual member functions.
     PrettyFunctionNoVirtual
   };
 
 private:
   PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
-                 bool IsTransparent, StringLiteral *SL);
+                 StringLiteral::StringKind E, bool IsTransparent,
+                 StringLiteral *SL);
 
   explicit PredefinedExpr(EmptyShell Empty, bool HasFunctionName);
 
   /// True if this PredefinedExpr has storage for a function name.
   bool hasFunctionName() const { return PredefinedExprBits.HasFunctionName; }
 
   void setFunctionName(StringLiteral *SL) {
     assert(hasFunctionName() &&
            "This PredefinedExpr has no storage for a function name!");
     *getTrailingObjects<Stmt *>() = SL;
   }
 
 public:
   /// Create a PredefinedExpr.
   ///
   /// If IsTransparent, the PredefinedExpr is transparently handled as a
   /// StringLiteral.
   static PredefinedExpr *Create(const ASTContext &Ctx, SourceLocation L,
-                                QualType FNTy, IdentKind IK, bool IsTransparent,
+                                QualType FNTy, IdentKind IK,
+                                StringLiteral::StringKind E, bool IsTransparent,
                                 StringLiteral *SL);
 
   /// Create an empty PredefinedExpr.
   static PredefinedExpr *CreateEmpty(const ASTContext &Ctx,
                                      bool HasFunctionName);
 
   IdentKind getIdentKind() const {
     return static_cast<IdentKind>(PredefinedExprBits.Kind);
   }
 
+  StringLiteral::StringKind getEncoding() const {
+    return static_cast<StringLiteral::StringKind>(PredefinedExprBits.Encoding);
+  }
+
   bool isTransparent() const { return PredefinedExprBits.IsTransparent; }
 
   SourceLocation getLocation() const { return PredefinedExprBits.Loc; }
   void setLocation(SourceLocation L) { PredefinedExprBits.Loc = L; }
 
   StringLiteral *getFunctionName() {
     return hasFunctionName()
                ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
                : nullptr;
   }
 
   const StringLiteral *getFunctionName() const {
     return hasFunctionName()
                ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
                : nullptr;
   }
 
-  static StringRef getIdentKindName(IdentKind IK);
+  static StringRef getIdentKindName(IdentKind IK,
+                                    StringLiteral::StringKind Encoding);
   StringRef getIdentKindName() const {
-    return getIdentKindName(getIdentKind());
+    return getIdentKindName(getIdentKind(), getEncoding());
   }
 
   static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl);
 
   SourceLocation getBeginLoc() const { return getLocation(); }
   SourceLocation getEndLoc() const { return getLocation(); }
 
   static bool classof(const Stmt *T) {

clang/include/clang/AST/Stmt.h

protected:
   class PredefinedExprBitfields {
     friend class ASTStmtReader;
     friend class PredefinedExpr;
 
     unsigned : NumExprBits;
 
     /// The kind of this PredefinedExpr. One of the enumeration values
     /// in PredefinedExpr::IdentKind.
-    unsigned Kind : 4;
+    unsigned Kind : 3;
+
+    /// The encoding of this predefined expression.
+    /// One of the enumeration values of StringLiteral::StringKind.
+    unsigned Encoding : 3;
 
     /// True if this PredefinedExpr has a trailing "StringLiteral *"
     /// for the predefined identifier.
     unsigned HasFunctionName : 1;
 
     /// True if this PredefinedExpr should be treated as a StringLiteral (for
     /// MSVC compatibility).
     unsigned IsTransparent : 1;

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__FUNCTION__                , KEYALL)
 KEYWORD(__PRETTY_FUNCTION__         , KEYALL)
 KEYWORD(__auto_type                 , KEYALL)
 
 // MS Extensions
 KEYWORD(__FUNCDNAME__               , KEYMS)
 KEYWORD(__FUNCSIG__                 , KEYMS)
 KEYWORD(L__FUNCTION__               , KEYMS)
+KEYWORD(L__FUNCDNAME__              , KEYMS)
 KEYWORD(L__FUNCSIG__                , KEYMS)
+KEYWORD(u8__FUNCTION__              , KEYMS)
+KEYWORD(u8__FUNCDNAME__             , KEYMS)
+KEYWORD(u8__FUNCSIG__               , KEYMS)
+KEYWORD(u__FUNCTION__               , KEYMS)
+KEYWORD(u__FUNCDNAME__              , KEYMS)
+KEYWORD(u__FUNCSIG__                , KEYMS)
+KEYWORD(U__FUNCTION__               , KEYMS)
+KEYWORD(U__FUNCDNAME__              , KEYMS)
+KEYWORD(U__FUNCSIG__                , KEYMS)
 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS)
 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
 
 // MSVC12.0 / VS2013 Type Traits
 TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYALL)
 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX)
 TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYALL)
 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)

clang/include/clang/Sema/Sema.h

ExprResult BuildLiteralOperatorCall(LookupResult &R,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
 
   // ExpandFunctionLocalPredefinedMacros - Returns a new vector of Tokens,
   // where Tokens representing function local predefined macros (such as
   // __FUNCTION__) are replaced (expanded) with string-literal Tokens.
   std::vector<Token> ExpandFunctionLocalPredefinedMacros(ArrayRef<Token> Toks);
 
   ExprResult BuildPredefinedExpr(SourceLocation Loc,
-                                 PredefinedExpr::IdentKind IK);
+                                 PredefinedExpr::IdentKind IK,
+                                 StringLiteral::StringKind E);
   ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
   ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
 
   ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                            SourceLocation LParen,
                                            SourceLocation RParen,
                                            TypeSourceInfo *TSI);
   ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc,

clang/lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
   Error Err = Error::success();
   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
   auto ToType = importChecked(Err, E->getType());
   auto ToFunctionName = importChecked(Err, E->getFunctionName());
   if (Err)
     return std::move(Err);
 
   return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType,
-                                E->getIdentKind(), E->isTransparent(),
-                                ToFunctionName);
+                                E->getIdentKind(), E->getEncoding(),
+                                E->isTransparent(), ToFunctionName);
 }
 
 ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
 
   Error Err = Error::success();
   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
   auto ToDecl = importChecked(Err, E->getDecl());

clang/lib/AST/Expr.cpp

std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context,
   Buffer.reserve(128);
   llvm::raw_string_ostream Out(Buffer);
   Ctx->mangleTypeName(Ty, Out);
 
   return Out.str();
 }
 
 PredefinedExpr::PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
-                               bool IsTransparent, StringLiteral *SL)
+                               StringLiteral::StringKind E, bool IsTransparent,
+                               StringLiteral *SL)
     : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary) {
   PredefinedExprBits.Kind = IK;
   assert((getIdentKind() == IK) &&
          "IdentKind do not fit in PredefinedExprBitfields!");
+  PredefinedExprBits.Encoding = E;
+  assert((getEncoding() == E) &&
+         "Encoding do not fit in PredefinedExprBitfields!");
   bool HasFunctionName = SL != nullptr;
   PredefinedExprBits.HasFunctionName = HasFunctionName;
   PredefinedExprBits.IsTransparent = IsTransparent;
   PredefinedExprBits.Loc = L;
   if (HasFunctionName)
     setFunctionName(SL);
   setDependence(computeDependence(this));
 }
 
 PredefinedExpr::PredefinedExpr(EmptyShell Empty, bool HasFunctionName)
     : Expr(PredefinedExprClass, Empty) {
   PredefinedExprBits.HasFunctionName = HasFunctionName;
 }
 
 PredefinedExpr *PredefinedExpr::Create(const ASTContext &Ctx, SourceLocation L,
                                        QualType FNTy, IdentKind IK,
+                                       StringLiteral::StringKind E,
                                        bool IsTransparent, StringLiteral *SL) {
   bool HasFunctionName = SL != nullptr;
   void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
                            alignof(PredefinedExpr));
-  return new (Mem) PredefinedExpr(L, FNTy, IK, IsTransparent, SL);
+  return new (Mem) PredefinedExpr(L, FNTy, IK, E, IsTransparent, SL);
 }
 
 PredefinedExpr *PredefinedExpr::CreateEmpty(const ASTContext &Ctx,
                                             bool HasFunctionName) {
   void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
                            alignof(PredefinedExpr));
   return new (Mem) PredefinedExpr(EmptyShell(), HasFunctionName);
 }
 
-StringRef PredefinedExpr::getIdentKindName(PredefinedExpr::IdentKind IK) {
+StringRef PredefinedExpr::getIdentKindName(PredefinedExpr::IdentKind IK,
+                                           StringLiteral::StringKind E) {
   switch (IK) {
   case Func:
     return "__func__";
+
   case Function:
+    switch (E) {
+    case StringLiteral::Ordinary:
       return "__FUNCTION__";
+    case StringLiteral::Wide:
+      return "L__FUNCTION__";
+    case StringLiteral::UTF8:
+      return "u8__FUNCTION__";
+    case StringLiteral::UTF16:
+      return "u__FUNCTION__";
+    case StringLiteral::UTF32:
+      return "U__FUNCTION__";
+    case StringLiteral::Unevaluated:
+      llvm_unreachable("unexpected PredefinedExpr encoding");
+    }
+
   case FuncDName:
+    switch (E) {
+    case StringLiteral::Ordinary:
       return "__FUNCDNAME__";
-  case LFunction:
-    return "L__FUNCTION__";
-  case PrettyFunction:
-    return "__PRETTY_FUNCTION__";
+    case StringLiteral::Wide:
+      return "L__FUNCDNAME__";
+    case StringLiteral::UTF8:
+      return "u8__FUNCDNAME__";
+    case StringLiteral::UTF16:
+      return "u__FUNCDNAME__";
+    case StringLiteral::UTF32:
+      return "U__FUNCDNAME__";
+    case StringLiteral::Unevaluated:
+      llvm_unreachable("unexpected PredefinedExpr encoding");
+    }
+
   case FuncSig:
+    switch (E) {
+    case StringLiteral::Ordinary:
       return "__FUNCSIG__";
-  case LFuncSig:
+    case StringLiteral::Wide:
       return "L__FUNCSIG__";
+    case StringLiteral::UTF8:
+      return "u8__FUNCSIG__";
+    case StringLiteral::UTF16:
+      return "u__FUNCSIG__";
+    case StringLiteral::UTF32:
+      return "U__FUNCSIG__";
+    case StringLiteral::Unevaluated:
+      llvm_unreachable("unexpected PredefinedExpr encoding");
+    }
+
+  case PrettyFunction:
+    return "__PRETTY_FUNCTION__";
   case PrettyFunctionNoVirtual:
     break;
   }
   llvm_unreachable("Unknown ident kind for PredefinedExpr");
 }
 
 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
 // expr" policy instead.
if (isa<BlockDecl>(CurrentDecl)) {
     if (auto *DCBlock = dyn_cast<BlockDecl>(DC))
       // For nested blocks, propagate up to the parent.
       Out << ComputeName(IK, DCBlock);
     else if (auto *DCDecl = dyn_cast<Decl>(DC))
       Out << ComputeName(IK, DCDecl) << "_block_invoke";
     return std::string(Out.str());
   }
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
-    if (IK != PrettyFunction && IK != PrettyFunctionNoVirtual &&
-        IK != FuncSig && IK != LFuncSig)
+    if (IK != PrettyFunction && IK != PrettyFunctionNoVirtual && IK != FuncSig)
       return FD->getNameAsString();
 
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
 
     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
       if (MD->isVirtual() && IK != PrettyFunctionNoVirtual)
         Out << "virtual ";
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
     const FunctionDecl *Decl = FD;
     if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
       Decl = Pattern;
     const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
     const FunctionProtoType *FT = nullptr;
     if (FD->hasWrittenPrototype())
       FT = dyn_cast<FunctionProtoType>(AFT);
 
-    if (IK == FuncSig || IK == LFuncSig) {
+    if (IK == FuncSig) {
       switch (AFT->getCallConv()) {
       case CC_C: POut << "__cdecl "; break;
       case CC_X86StdCall: POut << "__stdcall "; break;
       case CC_X86FastCall: POut << "__fastcall "; break;
       case CC_X86ThisCall: POut << "__thiscall "; break;
       case CC_X86VectorCall: POut << "__vectorcall "; break;
       case CC_X86RegCall: POut << "__regcall "; break;
       // Only bother printing the conventions that MSVC knows about.
       default: break;
       }
     }
 
     FD->printQualifiedName(POut, Policy);
 
     POut << "(";
     if (FT) {
       for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {
         if (i) POut << ", ";
         POut << Decl->getParamDecl(i)->getType().stream(Policy);
       }
 
       if (FT->isVariadic()) {
         if (FD->getNumParams()) POut << ", ";
         POut << "...";
-      } else if ((IK == FuncSig || IK == LFuncSig ||
-                  !Context.getLangOpts().CPlusPlus) &&
+      } else if ((IK == FuncSig || !Context.getLangOpts().CPlusPlus) &&
                  !Decl->getNumParams()) {
         POut << "void";
       }
     }
     POut << ")";
 
     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
       assert(FT && "We must have a written prototype in this case.");

clang/lib/AST/JSONNodeDumper.cpp

 
 void JSONNodeDumper::VisitSYCLUniqueStableNameExpr(
     const SYCLUniqueStableNameExpr *E) {
   JOS.attribute("typeSourceInfo",
                 createQualType(E->getTypeSourceInfo()->getType()));
 }
 
 void JSONNodeDumper::VisitPredefinedExpr(const PredefinedExpr *PE) {
-  JOS.attribute("name", PredefinedExpr::getIdentKindName(PE->getIdentKind()));
+  JOS.attribute("name", PE->getIdentKindName());
 }
 
 void JSONNodeDumper::VisitUnaryOperator(const UnaryOperator *UO) {
   JOS.attribute("isPostfix", UO->isPostfix());
   JOS.attribute("opcode", UnaryOperator::getOpcodeStr(UO->getOpcode()));
   if (!UO->canOverflow())
     JOS.attribute("canOverflow", false);
 }

clang/lib/AST/StmtPrinter.cpp

 void StmtPrinter::VisitSYCLUniqueStableNameExpr(
     SYCLUniqueStableNameExpr *Node) {
   OS << "__builtin_sycl_unique_stable_name(";
   Node->getTypeSourceInfo()->getType().print(OS, Policy);
   OS << ")";
 }
 
 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
-  OS << PredefinedExpr::getIdentKindName(Node->getIdentKind());
+  OS << Node->getIdentKindName();
 }
 
 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
   CharacterLiteral::print(Node->getValue(), Node->getKind(), OS);
 }
 
 /// Prints the given expression using the original source text. Returns true on
 /// success, false otherwise.

clang/lib/AST/TextNodeDumper.cpp

 }
 
 void TextNodeDumper::VisitSYCLUniqueStableNameExpr(
     const SYCLUniqueStableNameExpr *Node) {
   dumpType(Node->getTypeSourceInfo()->getType());
 }
 
 void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
-  OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
+  OS << " " << Node->getIdentKindName();
 }
 
 void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " " << Node->getValue();
 }
 
 void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {

clang/lib/CodeGen/CGExpr.cpp

 }
 
 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
   auto SL = E->getFunctionName();
   assert(SL != nullptr && "No StringLiteral name in PredefinedExpr");
   StringRef FnName = CurFn->getName();
   if (FnName.startswith("\01"))
     FnName = FnName.substr(1);
-  StringRef NameItems[] = {
-      PredefinedExpr::getIdentKindName(E->getIdentKind()), FnName};
+  StringRef NameItems[] = {E->getIdentKindName(), FnName};
   std::string GVName = llvm::join(NameItems, NameItems + 2, ".");
   if (auto *BD = dyn_cast_or_null<BlockDecl>(CurCodeDecl)) {
     std::string Name = std::string(SL->getString());
     if (!Name.empty()) {
       unsigned Discriminator =
           CGM.getCXXABI().getMangleContext().getBlockId(BD, true);
       if (Discriminator)
         Name += "_" + Twine(Discriminator + 1).str();

clang/lib/Lex/LiteralSupport.cpp

for (StringRef::iterator I = Input.begin(), E = Input.end(); I != E; ++I) {
     appendCodePoint(CodePoint, Buf);
     --I;
   }
 }
 
 bool clang::isFunctionLocalStringLiteralMacro(tok::TokenKind K,
                                               const LangOptions &LO) {
   return LO.MicrosoftExt &&
-         (K == tok::kw___FUNCTION__ || K == tok::kw_L__FUNCTION__ ||
-          K == tok::kw___FUNCSIG__ || K == tok::kw_L__FUNCSIG__ ||
-          K == tok::kw___FUNCDNAME__);
+         (K == tok::kw___FUNCTION__ || K == tok::kw___FUNCDNAME__ ||
+          K == tok::kw___FUNCSIG__ || K == tok::kw_L__FUNCTION__ ||
+          K == tok::kw_L__FUNCDNAME__ || K == tok::kw_L__FUNCSIG__ ||
+          K == tok::kw_u8__FUNCTION__ || K == tok::kw_u8__FUNCDNAME__ ||
+          K == tok::kw_u8__FUNCSIG__ || K == tok::kw_u__FUNCTION__ ||
+          K == tok::kw_u__FUNCDNAME__ || K == tok::kw_u__FUNCSIG__ ||
+          K == tok::kw_U__FUNCTION__ || K == tok::kw_U__FUNCDNAME__ ||
+          K == tok::kw_U__FUNCSIG__);
 }
 
 bool clang::tokenIsLikeStringLiteral(const Token &Tok, const LangOptions &LO) {
   return tok::isStringLiteral(Tok.getKind()) ||
          isFunctionLocalStringLiteralMacro(Tok.getKind(), LO);
 }
 
 static bool ProcessNumericUCNEscape(const char *ThisTokBegin,

clang/lib/Parse/ParseExpr.cpp

case tok::utf32_char_constant:
     Res = Actions.ActOnCharacterConstant(Tok, /*UDLScope*/getCurScope());
     ConsumeToken();
     break;
   case tok::kw___func__:       // primary-expression: __func__ [C99 6.4.2.2]
   case tok::kw___FUNCTION__:   // primary-expression: __FUNCTION__ [GNU]
   case tok::kw___FUNCDNAME__:   // primary-expression: __FUNCDNAME__ [MS]
   case tok::kw___FUNCSIG__:     // primary-expression: __FUNCSIG__ [MS]
   case tok::kw_L__FUNCTION__:   // primary-expression: L__FUNCTION__ [MS]
+  case tok::kw_L__FUNCDNAME__:  // primary-expression: L__FUNCDNAME__ [MS]
   case tok::kw_L__FUNCSIG__:    // primary-expression: L__FUNCSIG__ [MS]
+  case tok::kw_u8__FUNCTION__:  // primary-expression: u8__FUNCTION__ [MS]
+  case tok::kw_u8__FUNCDNAME__: // primary-expression: u8__FUNCDNAME__ [MS]
+  case tok::kw_u8__FUNCSIG__:   // primary-expression: u8__FUNCSIG__ [MS]
+  case tok::kw_u__FUNCTION__:   // primary-expression: u__FUNCTION__ [MS]
+  case tok::kw_u__FUNCDNAME__:  // primary-expression: u__FUNCDNAME__ [MS]
+  case tok::kw_u__FUNCSIG__:    // primary-expression: u__FUNCSIG__ [MS]
+  case tok::kw_U__FUNCTION__:   // primary-expression: U__FUNCTION__ [MS]
+  case tok::kw_U__FUNCDNAME__:  // primary-expression: U__FUNCDNAME__ [MS]
+  case tok::kw_U__FUNCSIG__:    // primary-expression: U__FUNCSIG__ [MS]
   case tok::kw___PRETTY_FUNCTION__:  // primary-expression: __P..Y_F..N__ [GNU]
     // Function local predefined macros are represented by PredefinedExpr except
     // when Microsoft extensions are enabled and one of these macros is adjacent
     // to a string literal or another one of these macros.
     if (!(getLangOpts().MicrosoftExt &&
           tokenIsLikeStringLiteral(Tok, getLangOpts()) &&
           tokenIsLikeStringLiteral(NextToken(), getLangOpts()))) {
       Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);

clang/lib/Sema/SemaExpr.cpp

return GenericSelectionExpr::Create(
         Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
         ContainsUnexpandedParameterPack, ResultIndex);
   }
   return GenericSelectionExpr::Create(
       Context, KeyLoc, ControllingType, Types, Exprs, DefaultLoc, RParenLoc,
       ContainsUnexpandedParameterPack, ResultIndex);
 }
 
-static PredefinedExpr::IdentKind getPredefinedExprKind(tok::TokenKind Kind) {
+static std::pair<PredefinedExpr::IdentKind, StringLiteral::StringKind>
+getPredefinedExprKind(tok::TokenKind Kind) {
   switch (Kind) {
   default:
     llvm_unreachable("unexpected TokenKind");
   case tok::kw___func__:
-    return PredefinedExpr::Func; // [C99 6.4.2.2]
+    return {PredefinedExpr::Func, StringLiteral::Ordinary}; // [C99 6.4.2.2]
   case tok::kw___FUNCTION__:
-    return PredefinedExpr::Function;
+    return {PredefinedExpr::Function, StringLiteral::Ordinary};
   case tok::kw___FUNCDNAME__:
-    return PredefinedExpr::FuncDName; // [MS]
+    return {PredefinedExpr::FuncDName, StringLiteral::Ordinary}; // [MS]
   case tok::kw___FUNCSIG__:
-    return PredefinedExpr::FuncSig; // [MS]
+    return {PredefinedExpr::FuncSig, StringLiteral::Ordinary}; // [MS]
   case tok::kw_L__FUNCTION__:
-    return PredefinedExpr::LFunction; // [MS]
+    return {PredefinedExpr::Function, StringLiteral::Wide}; // [MS]
+  case tok::kw_L__FUNCDNAME__:
+    return {PredefinedExpr::FuncDName, StringLiteral::Wide}; // [MS]
   case tok::kw_L__FUNCSIG__:
-    return PredefinedExpr::LFuncSig; // [MS]
+    return {PredefinedExpr::FuncSig, StringLiteral::Wide}; // [MS]
+  case tok::kw_u8__FUNCTION__:
+    return {PredefinedExpr::Function, StringLiteral::UTF8}; // [MS]
+  case tok::kw_u8__FUNCDNAME__:
+    return {PredefinedExpr::FuncDName, StringLiteral::UTF8}; // [MS]
+  case tok::kw_u8__FUNCSIG__:
+    return {PredefinedExpr::FuncSig, StringLiteral::UTF8}; // [MS]
+  case tok::kw_u__FUNCTION__:
+    return {PredefinedExpr::Function, StringLiteral::UTF16}; // [MS]
+  case tok::kw_u__FUNCDNAME__:
+    return {PredefinedExpr::FuncDName, StringLiteral::UTF16}; // [MS]
+  case tok::kw_u__FUNCSIG__:
+    return {PredefinedExpr::FuncSig, StringLiteral::UTF16}; // [MS]
+  case tok::kw_U__FUNCTION__:
+    return {PredefinedExpr::Function, StringLiteral::UTF32}; // [MS]
+  case tok::kw_U__FUNCDNAME__:
+    return {PredefinedExpr::FuncDName, StringLiteral::UTF32}; // [MS]
+  case tok::kw_U__FUNCSIG__:
+    return {PredefinedExpr::FuncSig, StringLiteral::UTF32}; // [MS]
   case tok::kw___PRETTY_FUNCTION__:
-    return PredefinedExpr::PrettyFunction; // [GNU]
+    return {PredefinedExpr::PrettyFunction, StringLiteral::Ordinary}; // [GNU]
   }
 }
 
 /// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the
 /// location of the token and the offset of the ud-suffix within it.
 static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc,
                                      unsigned Offset) {
   return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(),
if (!isFunctionLocalStringLiteralMacro(Tok.getKind(), getLangOpts())) {
       ExpandedToks.emplace_back(Tok);
       continue;
     }
     if (isa<TranslationUnitDecl>(CurrentDecl))
       Diag(Tok.getLocation(), diag::ext_predef_outside_function);
     // Stringify predefined expression
     Diag(Tok.getLocation(), diag::ext_string_literal_from_predefined)
         << Tok.getKind();
+    auto [ExprKind, Encoding] = getPredefinedExprKind(Tok.getKind());
     SmallString<64> Str;
     llvm::raw_svector_ostream OS(Str);
     Token &Exp = ExpandedToks.emplace_back();
     Exp.startToken();
-    if (Tok.getKind() == tok::kw_L__FUNCTION__ ||
-        Tok.getKind() == tok::kw_L__FUNCSIG__) {
+    switch (Encoding) {
+    case StringLiteral::Ordinary:
+      Exp.setKind(tok::string_literal);
+      break;
+    case StringLiteral::Wide:
       OS << 'L';
       Exp.setKind(tok::wide_string_literal);
-    } else {
-      Exp.setKind(tok::string_literal);
+      break;
+    case StringLiteral::UTF8:
+      OS << "u8";
+      Exp.setKind(tok::utf8_string_literal);
+      break;
+    case StringLiteral::UTF16:
+      OS << 'u';
+      Exp.setKind(tok::utf16_string_literal);
+      break;
+    case StringLiteral::UTF32:
+      OS << 'U';
+      Exp.setKind(tok::utf32_string_literal);
+      break;
+    case StringLiteral::Unevaluated:
+      llvm_unreachable("unexpected encoding");
     }
     OS << '"'
-       << Lexer::Stringify(PredefinedExpr::ComputeName(
-              getPredefinedExprKind(Tok.getKind()), CurrentDecl))
+       << Lexer::Stringify(PredefinedExpr::ComputeName(ExprKind, CurrentDecl))
        << '"';
     PP.CreateString(OS.str(), Exp, Tok.getLocation(), Tok.getEndLoc());
   }
   return ExpandedToks;
 }
 
 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
 /// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
#include "clang/AST/DeclNodes.inc"
   // RecoveryExpr to avoid follow-up semantic analysis (thus prevent bogus
   // diagnostics).
   if (VD->isInvalidDecl() && E)
     return CreateRecoveryExpr(E->getBeginLoc(), E->getEndLoc(), {E});
   return E;
 }
 
 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
-                                    SmallString<32> &Target) {
+                                    SmallVectorImpl<char> &Target) {
   Target.resize(CharByteWidth * (Source.size() + 1));
   char *ResultPtr = &Target[0];
   const llvm::UTF8 *ErrorPtr;
   bool success =
       llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
   (void)success;
   assert(success);
   Target.resize(ResultPtr - &Target[0]);
 }
 
 ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
-                                     PredefinedExpr::IdentKind IK) {
+                                     PredefinedExpr::IdentKind IK,
+                                     StringLiteral::StringKind E) {
   Decl *currentDecl = getCurLocalScopeDecl();
   if (!currentDecl) {
     Diag(Loc, diag::ext_predef_outside_function);
     currentDecl = Context.getTranslationUnitDecl();
   }
 
   QualType ResTy;
   StringLiteral *SL = nullptr;
   if (cast<DeclContext>(currentDecl)->isDependentContext())
     ResTy = Context.DependentTy;
   else {
-    // Pre-defined identifiers are of type char[x], where x is the length of
-    // the string.
+    // Pre-defined identifiers are of type CharT[x],
+    // where x is the length of the string.
+    SmallString<128> RawChars;
     auto Str = PredefinedExpr::ComputeName(IK, currentDecl);
-    unsigned Length = Str.length();
+    llvm::APInt LengthI(32, Str.length() + 1);
 
-    llvm::APInt LengthI(32, Length + 1);
-    if (IK == PredefinedExpr::LFunction || IK == PredefinedExpr::LFuncSig) {
-      ResTy =
-          Context.adjustStringLiteralBaseType(Context.WideCharTy.withConst());
-      SmallString<32> RawChars;
-      ConvertUTF8ToWideString(Context.getTypeSizeInChars(ResTy).getQuantity(),
-                              Str, RawChars);
-      ResTy = Context.getConstantArrayType(ResTy, LengthI, nullptr,
-                                           ArrayType::Normal,
-                                           /*IndexTypeQuals*/ 0);
-      SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide,
-                                 /*Pascal*/ false, ResTy, Loc);
-    } else {
-      ResTy = Context.adjustStringLiteralBaseType(Context.CharTy.withConst());
-      ResTy = Context.getConstantArrayType(ResTy, LengthI, nullptr,
-                                           ArrayType::Normal,
-                                           /*IndexTypeQuals*/ 0);
-      SL = StringLiteral::Create(Context, Str, StringLiteral::Ordinary,
-                                 /*Pascal*/ false, ResTy, Loc);
-    }
+    switch (E) {
+    case StringLiteral::Ordinary:
+      ResTy = Context.CharTy;
+      break;
+    case StringLiteral::Wide:
+      ResTy = Context.WideCharTy;
+      break;
+    case StringLiteral::UTF8:
+      ResTy = Context.Char8Ty;
+      break;
+    case StringLiteral::UTF16:
+      ResTy = Context.Char16Ty;
+      break;
+    case StringLiteral::UTF32:
+      ResTy = Context.Char32Ty;
+      break;
+    default:
+      llvm_unreachable("unexpected PredefinedExpr encoding");
+    }
+
+    ResTy = Context.adjustStringLiteralBaseType(ResTy.withConst());
+    ResTy = Context.getConstantArrayType(
+        ResTy, LengthI, nullptr, ArrayType::Normal, /*IndexTypeQuals*/ 0);
+    SL = StringLiteral::Create(Context, RawChars, E, /*Pascal*/ false, ResTy,
+                               Loc);
   }
 
-  return PredefinedExpr::Create(Context, Loc, ResTy, IK, LangOpts.MicrosoftExt,
-                                SL);
+  return PredefinedExpr::Create(Context, Loc, ResTy, IK, E,
+                                LangOpts.MicrosoftExt, SL);
 }
 
 ExprResult Sema::BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                                SourceLocation LParen,
                                                SourceLocation RParen,
                                                TypeSourceInfo *TSI) {
   return SYCLUniqueStableNameExpr::Create(Context, OpLoc, LParen, RParen, TSI);
 }
if (Ty.isNull())
     return ExprError();
   if (!TSI)
     TSI = Context.getTrivialTypeSourceInfo(Ty, LParen);
 
   return BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
 }
 
 ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) {
-  return BuildPredefinedExpr(Loc, getPredefinedExprKind(Kind));
+  auto [ExprKind, Encoding] = getPredefinedExprKind(Kind);
+  return BuildPredefinedExpr(Loc, ExprKind, Encoding);
 }
 
 ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
   SmallString<16> CharBuffer;
   bool Invalid = false;
   StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
   if (Invalid)
     return ExprError();

clang/lib/Sema/SemaTemplateInstantiate.cpp

return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
                                           AllowInjectedClassName);
 }
 
 ExprResult
 TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
   if (!E->isTypeDependent())
     return E;
 
-  return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentKind());
+  return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentKind(),
+                                       E->getEncoding());
 }
 
 ExprResult
 TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
                                                NonTypeTemplateParmDecl *NTTP) {
   // If the corresponding template argument is NULL or non-existent, it's
   // because we are performing instantiation from explicitly-specified
   // template arguments in a function template, but there were some

clang/lib/Sema/TreeTransform.h

ExprResult RebuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
     return getSema().BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
   }
 
   /// Build a new predefined expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildPredefinedExpr(SourceLocation Loc,
-                                   PredefinedExpr::IdentKind IK) {
-    return getSema().BuildPredefinedExpr(Loc, IK);
+                                   PredefinedExpr::IdentKind IK,
+                                   StringLiteral::StringKind E) {
+    return getSema().BuildPredefinedExpr(Loc, IK, E);
   }
 
   /// Build a new expression that references a declaration.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                         LookupResult &R,

 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
   if (!E->isTypeDependent())
     return E;
 
-  return getDerived().RebuildPredefinedExpr(E->getLocation(),
-                                            E->getIdentKind());
+  return getDerived().RebuildPredefinedExpr(E->getLocation(), E->getIdentKind(),
+                                            E->getEncoding());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
   NestedNameSpecifierLoc QualifierLoc;
   if (E->getQualifierLoc()) {
     QualifierLoc

clang/test/AST/Interp/literals.cpp

while (*str1 && *str2) {
       if (*str1++ != *str2++)
         return false;
     };
 
     return *str1 == *str2;
   }
 
   void foo() {
-    static_assert(strings_match(__FUNCSIG__, "void __cdecl PredefinedExprs::foo(void)"), "");
-    static_assert(strings_match(L__FUNCSIG__, L"void __cdecl PredefinedExprs::foo(void)"), "");
-    static_assert(strings_match(L__FUNCTION__, L"foo"), "");
-    static_assert(strings_match(__FUNCTION__, "foo"), "");
     static_assert(strings_match(__func__, "foo"), "");
+    static_assert(strings_match(__FUNCTION__, "foo"), "");
+    static_assert(strings_match(__FUNCDNAME__, "_ZN15PredefinedExprs3fooEv"), "");
+    static_assert(strings_match(__FUNCSIG__, "void __cdecl PredefinedExprs::foo(void)"), "");
     static_assert(strings_match(__PRETTY_FUNCTION__, "void PredefinedExprs::foo()"), "");
   }
 
   constexpr char heh(unsigned index) {
     __FUNCTION__;               // ref-warning {{result unused}} \
                                 // expected-warning {{result unused}}
     __extension__ __FUNCTION__; // ref-warning {{result unused}} \
                                 // expected-warning {{result unused}}

clang/test/Sema/ms_predefined_expr.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -Wmicrosoft -verify -fms-extensions
+// RUN: %clang_cc1 %s -fsyntax-only -Wmicrosoft -verify -fms-extensions -std=c++20
 
 using size_t = __SIZE_TYPE__;
 
 // Test array initialization
 void array_init() {
- const char a[] = __FUNCTION__; // expected-warning{{initializing an array from a '__FUNCTION__' predefined identifier is a Microsoft extension}}
- const char b[] = __FUNCDNAME__; // expected-warning{{initializing an array from a '__FUNCDNAME__' predefined identifier is a Microsoft extension}}
- const char c[] = __FUNCSIG__; // expected-warning{{initializing an array from a '__FUNCSIG__' predefined identifier is a Microsoft extension}}
- const char d[] = __func__; // expected-warning{{initializing an array from a '__func__' predefined identifier is a Microsoft extension}}
- const char e[] = __PRETTY_FUNCTION__; // expected-warning{{initializing an array from a '__PRETTY_FUNCTION__' predefined identifier is a Microsoft extension}}
- const wchar_t f[] = L__FUNCTION__; // expected-warning{{initializing an array from a 'L__FUNCTION__' predefined identifier is a Microsoft extension}}
- const wchar_t g[] = L__FUNCSIG__; // expected-warning{{initializing an array from a 'L__FUNCSIG__' predefined identifier is a Microsoft extension}}
+ const char a_f[] = __func__; // expected-warning{{initializing an array from a '__func__' predefined identifier is a Microsoft extension}}
+ const char a_P[] = __PRETTY_FUNCTION__; // expected-warning{{initializing an array from a '__PRETTY_FUNCTION__' predefined identifier is a Microsoft extension}}
+
+ const char a_F[] = __FUNCTION__;  // expected-warning{{initializing an array from a '__FUNCTION__' predefined identifier is a Microsoft extension}}
+ const char a_D[] = __FUNCDNAME__; // expected-warning{{initializing an array from a '__FUNCDNAME__' predefined identifier is a Microsoft extension}}
+ const char a_S[] = __FUNCSIG__;   // expected-warning{{initializing an array from a '__FUNCSIG__' predefined identifier is a Microsoft extension}}
+
+ const wchar_t L_F[] = L__FUNCTION__;  // expected-warning{{initializing an array from a 'L__FUNCTION__' predefined identifier is a Microsoft extension}}
+ const wchar_t L_D[] = L__FUNCDNAME__; // expected-warning{{initializing an array from a 'L__FUNCDNAME__' predefined identifier is a Microsoft extension}}
+ const wchar_t L_S[] = L__FUNCSIG__;   // expected-warning{{initializing an array from a 'L__FUNCSIG__' predefined identifier is a Microsoft extension}}
+
+ const char8_t u8_F[] = u8__FUNCTION__;  // expected-warning{{initializing an array from a 'u8__FUNCTION__' predefined identifier is a Microsoft extension}}
+ const char8_t u8_D[] = u8__FUNCDNAME__; // expected-warning{{initializing an array from a 'u8__FUNCDNAME__' predefined identifier is a Microsoft extension}}
+ const char8_t u8_S[] = u8__FUNCSIG__;   // expected-warning{{initializing an array from a 'u8__FUNCSIG__' predefined identifier is a Microsoft extension}}
+
+ const char16_t u_F[] = u__FUNCTION__;  // expected-warning{{initializing an array from a 'u__FUNCTION__' predefined identifier is a Microsoft extension}}
+ const char16_t u_D[] = u__FUNCDNAME__; // expected-warning{{initializing an array from a 'u__FUNCDNAME__' predefined identifier is a Microsoft extension}}
+ const char16_t u_S[] = u__FUNCSIG__;   // expected-warning{{initializing an array from a 'u__FUNCSIG__' predefined identifier is a Microsoft extension}}
+
+ const char32_t U_F[] = U__FUNCTION__;  // expected-warning{{initializing an array from a 'U__FUNCTION__' predefined identifier is a Microsoft extension}}
+ const char32_t U_D[] = U__FUNCDNAME__; // expected-warning{{initializing an array from a 'U__FUNCDNAME__' predefined identifier is a Microsoft extension}}
+ const char32_t U_S[] = U__FUNCSIG__;   // expected-warning{{initializing an array from a 'U__FUNCSIG__' predefined identifier is a Microsoft extension}}
 }
 
 // Test function local identifiers outside of a function
 const char* g_function = __FUNCTION__;            // expected-warning{{predefined identifier is only valid inside function}}
 const char* g_function_lconcat = "" __FUNCTION__; // expected-warning{{predefined identifier is only valid inside function}} \
                                                   // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
 const char* g_function_rconcat = __FUNCTION__ ""; // expected-warning{{predefined identifier is only valid inside function}} \
                                                   // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
extern "C" void test_concat() {
   ASSERT_EQ("left " __FUNCSIG__ " right", "left void __cdecl test_concat(void) right"); // expected-warning{{expansion of predefined identifier '__FUNCSIG__' to a string literal is a Microsoft extension}}
 
   ASSERT_EQ(__FUNCTION__ "/" __FUNCSIG__, "test_concat/void __cdecl test_concat(void)"); // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}} \
                                                                                          // expected-warning{{expansion of predefined identifier '__FUNCSIG__' to a string literal is a Microsoft extension}}
 }
 
 extern "C" void test_wide_concat() {
   // test L"" + ""
-  ASSERT_EQ(L"" __FUNCTION__, L__FUNCTION__); // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
-  ASSERT_EQ(L"" __FUNCSIG__, L__FUNCSIG__);   // expected-warning{{expansion of predefined identifier '__FUNCSIG__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L"" __FUNCTION__, L__FUNCTION__);   // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L"" __FUNCDNAME__, L__FUNCDNAME__); // expected-warning{{expansion of predefined identifier '__FUNCDNAME__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L"" __FUNCSIG__, L__FUNCSIG__);     // expected-warning{{expansion of predefined identifier '__FUNCSIG__' to a string literal is a Microsoft extension}}
 
   // test Lx + ""
-  ASSERT_EQ(L__FUNCTION__, L__FUNCTION__ ""); // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
-  ASSERT_EQ(L__FUNCSIG__, L__FUNCSIG__ "");   // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L__FUNCTION__, L__FUNCTION__ "");   // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L__FUNCDNAME__, L__FUNCDNAME__ ""); // expected-warning{{expansion of predefined identifier 'L__FUNCDNAME__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L__FUNCSIG__, L__FUNCSIG__ "");     // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
 
   ASSERT_EQ(L"left_" L__FUNCTION__, L"left_test_wide_concat");                   // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L"left_" L__FUNCDNAME__, L"left_test_wide_concat");                  // expected-warning{{expansion of predefined identifier 'L__FUNCDNAME__' to a string literal is a Microsoft extension}}
   ASSERT_EQ(L"left " L__FUNCSIG__, L"left void __cdecl test_wide_concat(void)"); // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
 
   ASSERT_EQ(L__FUNCTION__ L"_right", L"test_wide_concat_right");                   // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L__FUNCDNAME__ L"_right", L"test_wide_concat_right");                  // expected-warning{{expansion of predefined identifier 'L__FUNCDNAME__' to a string literal is a Microsoft extension}}
   ASSERT_EQ(L__FUNCSIG__ L" right", L"void __cdecl test_wide_concat(void) right"); // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
 
   ASSERT_EQ(L"left_" L__FUNCTION__ L"_right", L"left_test_wide_concat_right");                   // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L"left_" L__FUNCDNAME__ L"_right", L"left_test_wide_concat_right");                  // expected-warning{{expansion of predefined identifier 'L__FUNCDNAME__' to a string literal is a Microsoft extension}}
   ASSERT_EQ(L"left " L__FUNCSIG__ L" right", L"left void __cdecl test_wide_concat(void) right"); // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
 
-  ASSERT_EQ(L__FUNCTION__ L"/" L__FUNCSIG__, L"test_wide_concat/void __cdecl test_wide_concat(void)"); // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}} \
-                                                                                                       // expected-warning{{expansion of predefined identifier 'L__FUNCSIG__' to a string literal is a Microsoft extension}}
+  ASSERT_EQ(L__FUNCTION__ L"/" L__FUNCSIG__ L"/" L__FUNCDNAME__, L"test_wide_concat/void __cdecl test_wide_concat(void)/test_wide_concat"); // \
+      // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}} \
+      // expected-warning{{expansion of predefined identifier 'L__FUNCDNAME__' to a string literal is a Microsoft extension}} \
 }
 
 void test_encoding() {
   ASSERT_EQ_TY("" __FUNCTION__, "");     // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
   ASSERT_EQ_TY(L"" __FUNCTION__, L"");   // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}
   ASSERT_EQ_TY(L"" L__FUNCTION__, L"");  // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
   ASSERT_EQ_TY("" L__FUNCTION__, L"");   // expected-warning{{expansion of predefined identifier 'L__FUNCTION__' to a string literal is a Microsoft extension}}
   ASSERT_EQ_TY(u8"" __FUNCTION__, u8""); // expected-warning{{expansion of predefined identifier '__FUNCTION__' to a string literal is a Microsoft extension}}