[DO NOT SUBMIT] [Sema] Delay evaluation of std::source_location::current() in default arguments

[ilya-biryukov]

Summary

They must be evaluated in the context where default argument is actually
used during a call, not in a parameter list where default argument is specified.

Fixes #56379.

[cor3ntin]

I think this is superseded by https://cplusplus.github.io/CWG/issues/2631.html and its resolution.
Which I'm looking into implementing - I'll let you know if I manage to get it working (I still have a number of failing tests).
The idea is the same though, we keep a rewritten Expr in CXXDefaultArgExpr.

[ilya-biryukov]

In D132941#3826398, @cor3ntin wrote:

I think this is superseded by https://cplusplus.github.io/CWG/issues/2631.html and its resolution.
Which I'm looking into implementing - I'll let you know if I manage to get it working (I still have a number of failing tests).
The idea is the same though, we keep a rewritten Expr in CXXDefaultArgExpr.

LG, thanks for taking this over.
We chatted with @rsmith about this and one of the seemingly important optimizations that Richard suggested is to try avoiding the extra rewriting of expressions that don't have any immediate function calls.
Not sure how important this ends being for performance of compiling real code, but may be worth exploring.

[cor3ntin]

The PR for the more general approach (note that it does not solve source location, that will need more additional work) https://reviews.llvm.org/D136554

clang/include/clang/AST/CurrentSourceLocExprScope.h

 //===--- CurrentSourceLocExprScope.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines types used to track the current context needed to evaluate
 //  a SourceLocExpr.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_CURRENTSOURCELOCEXPRSCOPE_H
 #define LLVM_CLANG_AST_CURRENTSOURCELOCEXPRSCOPE_H
 
+#include "clang/AST/Expr.h"
+#include "llvm/ADT/Optional.h"
 #include <cassert>
 
 namespace clang {
 class Expr;
 
 /// Represents the current source location and context used to determine the
 /// value of the source location builtins (ex. __builtin_LINE), including the
 /// context of default argument and default initializer expressions.
 class CurrentSourceLocExprScope {
-  /// The CXXDefaultArgExpr or CXXDefaultInitExpr we're currently evaluating.
-  const Expr *DefaultExpr = nullptr;
+  /// The source locations coming from CXXDefaultArgExpr or CXXDefaultInitExpr
+  /// we're currently evaluating.
+  llvm::Optional<SourceLocExpr::Context> Context;
 
 public:
   /// A RAII style scope guard used for tracking the current source
   /// location and context as used by the source location builtins
   /// (ex. __builtin_LINE).
   class SourceLocExprScopeGuard;
 
-  const Expr *getDefaultExpr() const { return DefaultExpr; }
+  llvm::Optional<SourceLocExpr::Context> getSLocs() const { return Context; }
 
   explicit CurrentSourceLocExprScope() = default;
 
 private:
-  explicit CurrentSourceLocExprScope(const Expr *DefaultExpr)
-      : DefaultExpr(DefaultExpr) {}
-
-  CurrentSourceLocExprScope(CurrentSourceLocExprScope const &) = default;
-  CurrentSourceLocExprScope &
-  operator=(CurrentSourceLocExprScope const &) = default;
+  explicit CurrentSourceLocExprScope(
+      llvm::Optional<SourceLocExpr::Context> Context)
+      : Context(std::move(Context)) {}
 };
 
 class CurrentSourceLocExprScope::SourceLocExprScopeGuard {
 public:
-  SourceLocExprScopeGuard(const Expr *DefaultExpr,
+  SourceLocExprScopeGuard(SourceLocExpr::Context Context,
                           CurrentSourceLocExprScope &Current)
       : Current(Current), OldVal(Current), Enable(false) {
-    assert(DefaultExpr && "the new scope should not be empty");
-    if ((Enable = (Current.getDefaultExpr() == nullptr)))
-      Current = CurrentSourceLocExprScope(DefaultExpr);
+    if ((Enable = (!Current.getSLocs().has_value())))
+      Current = CurrentSourceLocExprScope(Context);
   }
 
   ~SourceLocExprScopeGuard() {
     if (Enable)
       Current = OldVal;
   }
 
 private:

clang/include/clang/AST/Expr.h

 #ifndef LLVM_CLANG_AST_EXPR_H
 #define LLVM_CLANG_AST_EXPR_H
 
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTVector.h"
 #include "clang/AST/ComputeDependence.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclAccessPair.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SyncScope.h"
namespace clang {
   class MaterializeTemporaryExpr;
   class NamedDecl;
   class ObjCPropertyRefExpr;
   class OpaqueValueExpr;
   class ParmVarDecl;
   class StringLiteral;
   class TargetInfo;
   class ValueDecl;
+  class CurrentSourceLocExprScope;
 
 /// A simple array of base specifiers.
 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
 
 /// An adjustment to be made to the temporary created when emitting a
 /// reference binding, which accesses a particular subobject of that temporary.
 struct SubobjectAdjustment {
   enum {
enum class ConstantExprKind {
     /// An immediate invocation. The destruction of the end result of this
     /// evaluation is not part of the evaluation, but all other temporaries
     /// are destroyed.
     ImmediateInvocation,
   };
 
   /// Evaluate an expression that is required to be a constant expression. Does
   /// not check the syntactic constraints for C and C++98 constant expressions.
-  bool EvaluateAsConstantExpr(
-      EvalResult &Result, const ASTContext &Ctx,
-      ConstantExprKind Kind = ConstantExprKind::Normal) const;
+  bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
+                              ConstantExprKind Kind = ConstantExprKind::Normal,
+                              CurrentSourceLocExprScope *SLocs = nullptr) const;
 
   /// If the current Expr is a pointer, this will try to statically
   /// determine the number of bytes available where the pointer is pointing.
   /// Returns true if all of the above holds and we were able to figure out the
   /// size, false otherwise.
   ///
   /// \param Type - How to evaluate the size of the Expr, as defined by the
   /// "type" parameter of __builtin_object_size
public:
 
   SourceLocExpr(const ASTContext &Ctx, IdentKind Type, QualType ResultTy,
                 SourceLocation BLoc, SourceLocation RParenLoc,
                 DeclContext *Context);
 
   /// Build an empty call expression.
   explicit SourceLocExpr(EmptyShell Empty) : Expr(SourceLocExprClass, Empty) {}
 
+  struct Context {
+    SourceLocation UsedLocation;
+    const DeclContext *UsedContext = nullptr;
+
+    static Context FromDefaultArg(const CXXDefaultArgExpr* E);
+    static Context FromDefaultInit(const CXXDefaultInitExpr* E);
+  };
+
   /// Return the result of evaluating this SourceLocExpr in the specified
   /// (and possibly null) default argument or initialization context.
   APValue EvaluateInContext(const ASTContext &Ctx,
-                            const Expr *DefaultExpr) const;
+                            llvm::Optional<Context> LocCtx) const;
 
   /// Return a string representing the name of the specific builtin function.
   StringRef getBuiltinStr() const;
 
   IdentKind getIdentKind() const {
     return static_cast<IdentKind>(SourceLocExprBits.Kind);
   }
 

clang/include/clang/AST/ExprCXX.h

public:
   }
 };
 
 /// A default argument (C++ [dcl.fct.default]).
 ///
 /// This wraps up a function call argument that was created from the
 /// corresponding parameter's default argument, when the call did not
 /// explicitly supply arguments for all of the parameters.
-class CXXDefaultArgExpr final : public Expr {
+class CXXDefaultArgExpr final
+    : public Expr,
+      private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
   friend class ASTStmtReader;
+  friend TrailingObjects;
 
   /// The parameter whose default is being used.
   ParmVarDecl *Param;
 
   /// The context where the default argument expression was used.
   DeclContext *UsedContext;
 
+  CXXDefaultArgExpr(EmptyShell Empty, bool HasRewrittenArg)
+      : Expr(CXXDefaultArgExprClass, Empty) {
+    CXXDefaultArgExprBits.HasRewrittenArg = HasRewrittenArg;
+  }
+
   CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
-                    DeclContext *UsedContext)
+                    DeclContext *UsedContext, Expr* RewrittenArg)
       : Expr(SC,
              Param->hasUnparsedDefaultArg()
                  ? Param->getType().getNonReferenceType()
                  : Param->getDefaultArg()->getType(),
              Param->getDefaultArg()->getValueKind(),
              Param->getDefaultArg()->getObjectKind()),
         Param(Param), UsedContext(UsedContext) {
+    CXXDefaultArgExprBits.HasRewrittenArg = !!RewrittenArg;
     CXXDefaultArgExprBits.Loc = Loc;
+    if (RewrittenArg)
+      *getTrailingObjects<Expr *>() = RewrittenArg;
     setDependence(computeDependence(this));
   }
 
+  size_t numTrailingObjects() const {
+    return CXXDefaultArgExprBits.HasRewrittenArg;
+  }
+
 public:
-  CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
+
+  static CXXDefaultArgExpr *CreateEmpty(const ASTContext &C, bool HasRewrittenArg) {
+    size_t Size = totalSizeToAlloc<Expr*>(HasRewrittenArg);
+    auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
+    return new (Mem) CXXDefaultArgExpr(EmptyShell(), HasRewrittenArg);
+  }
 
   // \p Param is the parameter whose default argument is used by this
   // expression.
   static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
                                    ParmVarDecl *Param,
-                                   DeclContext *UsedContext) {
-    return new (C)
-        CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
+                                   DeclContext *UsedContext,
+                                   Expr* RewrittenArg = nullptr) {
+    size_t Size = totalSizeToAlloc<Expr*>(RewrittenArg != nullptr);
+    auto *Mem = C.Allocate(Size, alignof(CXXDefaultArgExpr));
+    return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
+                                       UsedContext, RewrittenArg);
   }
 
+  bool hasRewrittenArg() const { return CXXDefaultArgExprBits.HasRewrittenArg; }
+
   // Retrieve the parameter that the argument was created from.
   const ParmVarDecl *getParam() const { return Param; }
   ParmVarDecl *getParam() { return Param; }
 
   // Retrieve the actual argument to the function call.
-  const Expr *getExpr() const { return getParam()->getDefaultArg(); }
-  Expr *getExpr() { return getParam()->getDefaultArg(); }
+  const Expr *getExpr() const {
+    if (CXXDefaultArgExprBits.HasRewrittenArg)
+      return *getTrailingObjects<Expr *>();
+    return getParam()->getDefaultArg();
+  }
+  Expr *getExpr() {
+    if (CXXDefaultArgExprBits.HasRewrittenArg)
+      return *getTrailingObjects<Expr *>();
+    return getParam()->getDefaultArg();
+  }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
   DeclContext *getUsedContext() { return UsedContext; }
 
   /// Retrieve the location where this default argument was actually used.
   SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
 
   /// Default argument expressions have no representation in the

clang/include/clang/AST/Stmt.h

protected:
   };
 
   class CXXDefaultArgExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultArgExpr;
 
     unsigned : NumExprBits;
 
+    /// Whether this CXXDefaultArgExpr rewrote its argument and stores a copy.
+    unsigned HasRewrittenArg : 1;
+
     /// The location where the default argument expression was used.
     SourceLocation Loc;
   };
 
   class CXXDefaultInitExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultInitExpr;
 

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitIfStmt(const IfStmt *Node);
   void VisitSwitchStmt(const SwitchStmt *Node);
   void VisitWhileStmt(const WhileStmt *Node);
   void VisitLabelStmt(const LabelStmt *Node);
   void VisitGotoStmt(const GotoStmt *Node);
   void VisitCaseStmt(const CaseStmt *Node);
   void VisitCompoundStmt(const CompoundStmt *Node);
   void VisitConstantExpr(const ConstantExpr *Node);
+  void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *Node);
   void VisitCallExpr(const CallExpr *Node);
   void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node);
   void VisitCastExpr(const CastExpr *Node);
   void VisitImplicitCastExpr(const ImplicitCastExpr *Node);
   void VisitDeclRefExpr(const DeclRefExpr *Node);
   void VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *Node);
   void VisitPredefinedExpr(const PredefinedExpr *Node);
   void VisitCharacterLiteral(const CharacterLiteral *Node);

clang/include/clang/Sema/Sema.h

 #ifndef LLVM_CLANG_SEMA_SEMA_H
 #define LLVM_CLANG_SEMA_SEMA_H
 
 #include "clang/AST/ASTConcept.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Availability.h"
 #include "clang/AST/ComparisonCategories.h"
+#include "clang/AST/CurrentSourceLocExprScope.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/ExternalASTSource.h"
struct ExpressionEvaluationContextRecord {
     }
 
     bool isDiscardedStatementContext() const {
       return Context == ExpressionEvaluationContext::DiscardedStatement ||
              (Context ==
                   ExpressionEvaluationContext::ImmediateFunctionContext &&
               InDiscardedStatement);
     }
+
+    bool isPotentiallyEvaluatedIfUsed() const {
+      return Context == ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed;
+    }
   };
 
   /// A stack of expression evaluation contexts.
   SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
+  /// Used to evaluate source locations.
+  CurrentSourceLocExprScope* OverridenSourceLocs = nullptr;
 
   /// Emit a warning for all pending noderef expressions that we recorded.
   void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
 
   /// Compute the mangling number context for a lambda expression or
   /// block literal. Also return the extra mangling decl if any.
   ///
   /// \param DC - The DeclContext containing the lambda expression or
BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                         unsigned ConstructKind, SourceRange ParenRange);
 
   ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
 
 
   /// Instantiate or parse a C++ default argument expression as necessary.
   /// Return true on error.
   bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
-                              ParmVarDecl *Param);
+                              ParmVarDecl *Param, Expr *&RewrittenArg);
 
   /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
   /// the default expr if needed.
   ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
                                     FunctionDecl *FD,
                                     ParmVarDecl *Param);
 
   /// FinalizeVarWithDestructor - Prepare for calling destructor on the

   }
 
   bool isImmediateFunctionContext() const {
     assert(!ExprEvalContexts.empty() &&
            "Must be in an expression evaluation context");
     return ExprEvalContexts.back().isImmediateFunctionContext();
   }
 
+  bool isPotentiallyEvaluatedIfUsedContext() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    return ExprEvalContexts.back().isPotentiallyEvaluatedIfUsed();
+  }
+
   /// RAII class used to determine whether SFINAE has
   /// trapped any errors that occur during template argument
   /// deduction.
   class SFINAETrap {
     Sema &SemaRef;
     unsigned PrevSFINAEErrors;
     bool PrevInNonInstantiationSFINAEContext;
     bool PrevAccessCheckingSFINAE;

clang/lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   if (!ToParam->getDefaultArg()) {
     Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
     assert(FromParam && "ParmVarDecl was not imported?");
 
     if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
       return std::move(Err);
   }
 
+  Expr* RewrittenArg = nullptr;
+  if (E->hasRewrittenArg()) {
+    auto ArgOrErr = import(E->getExpr());
+    if (!ArgOrErr) return ArgOrErr.takeError();
+    RewrittenArg = *ArgOrErr;
+  }
+
   return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
-                                   *ToParamOrErr, *UsedContextOrErr);
+                                   *ToParamOrErr, *UsedContextOrErr,
+                                   RewrittenArg);
 }
 
 ExpectedStmt
 ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());

clang/lib/AST/Expr.cpp

StringRef SourceLocExpr::getBuiltinStr() const {
   case Column:
     return "__builtin_COLUMN";
   case SourceLocStruct:
     return "__builtin_source_location";
   }
   llvm_unreachable("unexpected IdentKind!");
 }
 
+SourceLocExpr::Context
+SourceLocExpr::Context::FromDefaultArg(const CXXDefaultArgExpr *E) {
+  return {E->getUsedLocation(), E->getUsedContext()};
+}
+
+SourceLocExpr::Context
+SourceLocExpr::Context::FromDefaultInit(const CXXDefaultInitExpr *E) {
+  return {E->getUsedLocation(), E->getUsedContext()};
+}
+
 APValue SourceLocExpr::EvaluateInContext(const ASTContext &Ctx,
-                                         const Expr *DefaultExpr) const {
+                                         llvm::Optional<Context> LocCtx) const {
   SourceLocation Loc;
   const DeclContext *Context;
-
-  std::tie(Loc,
-           Context) = [&]() -> std::pair<SourceLocation, const DeclContext *> {
-    if (auto *DIE = dyn_cast_or_null<CXXDefaultInitExpr>(DefaultExpr))
-      return {DIE->getUsedLocation(), DIE->getUsedContext()};
-    if (auto *DAE = dyn_cast_or_null<CXXDefaultArgExpr>(DefaultExpr))
-      return {DAE->getUsedLocation(), DAE->getUsedContext()};
-    return {this->getLocation(), this->getParentContext()};
-  }();
-
+  if (LocCtx) {
+    Loc = LocCtx->UsedLocation;
+    Context = LocCtx->UsedContext;
+  } else {
+    Loc = this->getLocation();
+    Context = this->getParentContext();
+  }
   PresumedLoc PLoc = Ctx.getSourceManager().getPresumedLoc(
       Ctx.getSourceManager().getExpansionRange(Loc).getEnd());
 
   auto MakeStringLiteral = [&](StringRef Tmp) {
     using LValuePathEntry = APValue::LValuePathEntry;
     StringLiteral *Res = Ctx.getPredefinedStringLiteralFromCache(Tmp);
     // Decay the string to a pointer to the first character.
     LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};

clang/lib/AST/ExprConstant.cpp

public:
   bool VisitChooseExpr(const ChooseExpr *E)
     { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
   bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
     { return StmtVisitorTy::Visit(E->getResultExpr()); }
   bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
     { return StmtVisitorTy::Visit(E->getReplacement()); }
   bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
     TempVersionRAII RAII(*Info.CurrentCall);
-    SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
+    SourceLocExprScopeGuard Guard(SourceLocExpr::Context::FromDefaultArg(E),
+                                  Info.CurrentCall->CurSourceLocExprScope);
     return StmtVisitorTy::Visit(E->getExpr());
   }
   bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
     TempVersionRAII RAII(*Info.CurrentCall);
     // The initializer may not have been parsed yet, or might be erroneous.
     if (!E->getExpr())
       return Error(E);
-    SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
+    SourceLocExprScopeGuard Guard(SourceLocExpr::Context::FromDefaultInit(E),
+                                  Info.CurrentCall->CurSourceLocExprScope);
     return StmtVisitorTy::Visit(E->getExpr());
   }
 
   bool VisitExprWithCleanups(const ExprWithCleanups *E) {
     FullExpressionRAII Scope(Info);
     return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
   }
 
bool VisitCXXThisExpr(const CXXThisExpr *E) {
     return true;
   }
 
   bool VisitCXXNewExpr(const CXXNewExpr *E);
 
   bool VisitSourceLocExpr(const SourceLocExpr *E) {
     assert(!E->isIntType() && "SourceLocExpr isn't a pointer type?");
     APValue LValResult = E->EvaluateInContext(
-        Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
+        Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getSLocs());
     Result.setFrom(Info.Ctx, LValResult);
     return true;
   }
 
   bool VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E) {
     std::string ResultStr = E->ComputeName(Info.Ctx);
 
     QualType CharTy = Info.Ctx.CharTy.withConst();
if (!Val.isInt()) {
     return false;
   }
   Result = Val.getInt();
   return true;
 }
 
 bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) {
   APValue Evaluated = E->EvaluateInContext(
-      Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
+      Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getSLocs());
   return Success(Evaluated, E);
 }
 
 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
                                EvalInfo &Info) {
   assert(!E->isValueDependent());
   if (E->getType()->isFixedPointType()) {
     APValue Val;
if (!HandleDestruction(Info, Loc, Base, DestroyedValue, Type) ||
     return false;
 
   if (!Info.discardCleanups())
     llvm_unreachable("Unhandled cleanup; missing full expression marker?");
 
   return true;
 }
 
-bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
-                                  ConstantExprKind Kind) const {
+bool Expr::EvaluateAsConstantExpr(
+    EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind,
+    CurrentSourceLocExprScope *SLocs) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
   EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
   EvalInfo Info(Ctx, Result, EM);
   Info.InConstantContext = true;
+  if (SLocs) {
+    Info.BottomFrame.CurSourceLocExprScope = *SLocs;
+  }
 
   // The type of the object we're initializing is 'const T' for a class NTTP.
   QualType T = getType();
   if (Kind == ConstantExprKind::ClassTemplateArgument)
     T.addConst();
 
   // If we're evaluating a prvalue, fake up a MaterializeTemporaryExpr to
   // represent the result of the evaluation. CheckConstantExpression ensures

clang/lib/AST/TextNodeDumper.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TypeTraits.h"
 #include "llvm/ADT/StringExtras.h"
 

 }
 
 void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
   if (Node->hasAPValueResult())
     AddChild("value",
              [=] { Visit(Node->getAPValueResult(), Node->getType()); });
 }
 
+void TextNodeDumper::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr* Node) {
+  AddChild("expr", [=] { Node->getExpr()->dumpColor(); });
+}
+
 void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
   if (Node->usesADL())
     OS << " adl";
   if (Node->hasStoredFPFeatures())
     printFPOptions(Node->getFPFeatures());
 }
 
 void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) {

clang/lib/CodeGen/CGExprScalar.cpp

public:
 
   // C++
   Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
     return EmitLoadOfLValue(E);
   }
   Value *VisitSourceLocExpr(SourceLocExpr *SLE) {
     auto &Ctx = CGF.getContext();
     APValue Evaluated =
-        SLE->EvaluateInContext(Ctx, CGF.CurSourceLocExprScope.getDefaultExpr());
+        SLE->EvaluateInContext(Ctx, CGF.CurSourceLocExprScope.getSLocs());
     return ConstantEmitter(CGF).emitAbstract(SLE->getLocation(), Evaluated,
                                              SLE->getType());
   }
 
   Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
     CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
     return Visit(DAE->getExpr());
   }

clang/lib/CodeGen/CodeGenFunction.h

 #include "CGLoopInfo.h"
 #include "CGValue.h"
 #include "CodeGenModule.h"
 #include "CodeGenPGO.h"
 #include "EHScopeStack.h"
 #include "VarBypassDetector.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/CurrentSourceLocExprScope.h"
+#include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/CapturedStmt.h"
 #include "clang/Basic/CodeGenOptions.h"
public:
 
   /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
   /// is overridden to be the object under construction.
   class CXXDefaultInitExprScope  {
   public:
     CXXDefaultInitExprScope(CodeGenFunction &CGF, const CXXDefaultInitExpr *E)
         : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
           OldCXXThisAlignment(CGF.CXXThisAlignment),
-          SourceLocScope(E, CGF.CurSourceLocExprScope) {
+          SourceLocScope(SourceLocExpr::Context::FromDefaultInit(E),
+                         CGF.CurSourceLocExprScope) {
       CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getPointer();
       CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
     }
     ~CXXDefaultInitExprScope() {
       CGF.CXXThisValue = OldCXXThisValue;
       CGF.CXXThisAlignment = OldCXXThisAlignment;
     }
 
   public:
     CodeGenFunction &CGF;
     llvm::Value *OldCXXThisValue;
     CharUnits OldCXXThisAlignment;
     SourceLocExprScopeGuard SourceLocScope;
   };
 
   struct CXXDefaultArgExprScope : SourceLocExprScopeGuard {
     CXXDefaultArgExprScope(CodeGenFunction &CGF, const CXXDefaultArgExpr *E)
-        : SourceLocExprScopeGuard(E, CGF.CurSourceLocExprScope) {}
+        : SourceLocExprScopeGuard(SourceLocExpr::Context::FromDefaultArg(E),
+                                  CGF.CurSourceLocExprScope) {}
   };
 
   /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
   /// current loop index is overridden.
   class ArrayInitLoopExprScope {
   public:
     ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
       : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {

clang/lib/Sema/SemaDeclCXX.cpp

for (Decl *Member : Class->decls()) {
     auto *Attr = CD->getAttr<DLLExportAttr>();
     if (!Attr)
       continue;
 
     // If the class is non-dependent, mark the default arguments as ODR-used so
     // that we can properly codegen the constructor closure.
     if (!Class->isDependentContext()) {
       for (ParmVarDecl *PD : CD->parameters()) {
-        (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
+        Expr* Dummy;
+        (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD, Dummy);
         S.DiscardCleanupsInEvaluationContext();
       }
     }
 
     if (LastExportedDefaultCtor) {
       S.Diag(LastExportedDefaultCtor->getLocation(),
              diag::err_attribute_dll_ambiguous_default_ctor)
           << Class;

clang/lib/Sema/SemaExpr.cpp

 
 #include "TreeTransform.h"
 #include "UsedDeclVisitor.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/CXXInheritance.h"
+#include "clang/AST/CurrentSourceLocExprScope.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/OperationKinds.h"

 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/AnalysisBasedWarnings.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaFixItUtils.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/SaveAndRestore.h"
if (auto *TT =
       }
     }
   }
 
   return new (Context)
       ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc);
 }
 
+static bool IsStdSourceLocationCurrent(Decl* D) {
+  auto *F = D ? dyn_cast<FunctionDecl>(D) : nullptr;
+  auto *FuncName = F ? F->getIdentifier() : nullptr;
+  if (!FuncName || !FuncName->isStr("current") || !F->isConsteval())
+    return false;
+  auto *Cls = dyn_cast<RecordDecl>(F->getDeclContext());
+  auto *ClsName = Cls ? Cls->getIdentifier() : nullptr;
+  return ClsName && ClsName->isStr("source_location") && Cls->isInStdNamespace();
+}
+
+static bool IsCallToStdSourceLocationCurrent(Expr* E) {
+  CallExpr *Call = dyn_cast<CallExpr>(E);
+  auto *Callee = Call ? Call->getCalleeDecl() : nullptr;
+  return Callee && IsStdSourceLocationCurrent(Callee);
+}
+
+static ExprResult EvaluateSourceLocations(Sema &S, ParmVarDecl *Param,
+                                          SourceLocation CallLoc,
+                                          DeclContext *UsedContext);
+
 bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
-                                  ParmVarDecl *Param) {
+                                  ParmVarDecl *Param, Expr *&RewrittenArg) {
+  RewrittenArg = nullptr;
+
   if (Param->hasUnparsedDefaultArg()) {
     // If we've already cleared out the location for the default argument,
     // that means we're parsing it right now.
     if (!UnparsedDefaultArgLocs.count(Param)) {
       Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
       Diag(CallLoc, diag::note_recursive_default_argument_used_here);
       Param->setInvalidDecl();
       return true;
     }
 
     Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
         << FD << cast<CXXRecordDecl>(FD->getDeclContext());
     Diag(UnparsedDefaultArgLocs[Param],
          diag::note_default_argument_declared_here);
     return true;
   }
 
   if (Param->hasUninstantiatedDefaultArg() &&
       InstantiateDefaultArgument(CallLoc, FD, Param))
     return true;
 
   assert(Param->hasInit() && "default argument but no initializer?");
 
+  ExprResult NewArg = EvaluateSourceLocations(*this, Param, CallLoc, CurContext);
+  if (NewArg.isInvalid())
+    return true;
+  if (NewArg.get() != Param->getDefaultArg())
+    RewrittenArg = NewArg.get();
+
   // If the default expression creates temporaries, we need to
   // push them to the current stack of expression temporaries so they'll
   // be properly destroyed.
   // FIXME: We should really be rebuilding the default argument with new
   // bound temporaries; see the comment in PR5810.
   // We don't need to do that with block decls, though, because
   // blocks in default argument expression can never capture anything.
   if (auto Init = dyn_cast<ExprWithCleanups>(Param->getInit())) {
bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
   MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
                                    /*SkipLocalVariables=*/true);
   return false;
 }
 
 ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
                                         FunctionDecl *FD, ParmVarDecl *Param) {
   assert(Param->hasDefaultArg() && "can't build nonexistent default arg");
-  if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
+  Expr* RewrittenArg = nullptr;
+  if (CheckCXXDefaultArgExpr(CallLoc, FD, Param, RewrittenArg))
     return ExprError();
-  return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
+  return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext,
+                                   RewrittenArg);
 }
 
 Sema::VariadicCallType
 Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
                           Expr *Fn) {
   if (Proto && Proto->isVariadic()) {
     if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
       return VariadicConstructor;
ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
   /// Value-dependent constant expressions should not be immediately
   /// evaluated until they are instantiated.
   if (!Res->isValueDependent())
     ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
   return Res;
 }
 
 static void EvaluateAndDiagnoseImmediateInvocation(
-    Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate) {
+    Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate, bool InDefaultArg) {
   llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
   Expr::EvalResult Eval;
   Eval.Diag = &Notes;
   ConstantExpr *CE = Candidate.getPointer();
+  // [support.srcloc.cons]p2.
+  // Any call to current that appears as a default argument ([dcl.fct.default]),
+  // or as a subexpression thereof, should correspond to the location of the
+  // invocation of the function that uses the default argument ([expr.call]).
+  if (InDefaultArg && IsCallToStdSourceLocationCurrent(CE->getSubExpr()))
+    return; // Postpone evaluation until we see the context.
   bool Result = CE->EvaluateAsConstantExpr(
-      Eval, SemaRef.getASTContext(), ConstantExprKind::ImmediateInvocation);
+      Eval, SemaRef.getASTContext(), ConstantExprKind::ImmediateInvocation,
+      SemaRef.OverridenSourceLocs);
   if (!Result || !Notes.empty()) {
     Expr *InnerExpr = CE->getSubExpr()->IgnoreImplicit();
     if (auto *FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
       InnerExpr = FunctionalCast->getSubExpr();
     FunctionDecl *FD = nullptr;
     if (auto *Call = dyn_cast<CallExpr>(InnerExpr))
       FD = cast<FunctionDecl>(Call->getCalleeDecl());
     else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
       FD = Call->getConstructor();
     else
       llvm_unreachable("unhandled decl kind");
     assert(FD->isConsteval());
     SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
     for (auto &Note : Notes)
       SemaRef.Diag(Note.first, Note.second);
     return;
   }
   CE->MoveIntoResult(Eval.Val, SemaRef.getASTContext());
 }
 
+static ExprResult EvaluateSourceLocations(Sema &S, ParmVarDecl* Param,
+                                          SourceLocation CallLoc,
+                                          DeclContext *UsedContext) {
+  struct Transform : TreeTransform<Transform> {
+    using TreeTransform::TreeTransform;
+
+    bool AlwaysRebuild() { return OverrideAlwaysRebuild; }
+
+    ExprResult TransformCallExpr(CallExpr* Call) {
+      if (!IsCallToStdSourceLocationCurrent(Call))
+        return TreeTransform::TransformCallExpr(Call);
+      // Rebuild the call so it gets to the list of immedicate invocations.
+      llvm::SaveAndRestore<bool> Guard(OverrideAlwaysRebuild, true);
+      return TreeTransform::TransformCallExpr(Call);
+    }
+
+  private:
+    bool OverrideAlwaysRebuild = false;
+  };
+  // Force evaluation of calls to source_location::current().
+  // TODO(HACK): potentially evaluated is clearly wrong in some cases?
+  CurrentSourceLocExprScope Locs;
+  CurrentSourceLocExprScope::SourceLocExprScopeGuard LG(
+      SourceLocExpr::Context{CallLoc, UsedContext}, Locs);
+  llvm::SaveAndRestore<CurrentSourceLocExprScope *> SwapLocs(
+      S.OverridenSourceLocs, &Locs);
+
+  EnterExpressionEvaluationContext Eval(
+      S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
+      Sema::ReuseLambdaContextDecl_t{});
+  ExprResult NewArg = Transform(S).TransformExpr(Param->getDefaultArg());
+  if (NewArg.isUsable() && NewArg.get() != Param->getDefaultArg()) {
+    NewArg = S.ConvertParamDefaultArgument(Param, NewArg.get(),
+                                           NewArg.get()->getBeginLoc());
+  }
+  if (NewArg.isInvalid())
+    return NewArg;
+  // Mimic the logic of ParmVarDecl::getDefaultArg().
+  if (auto *E = dyn_cast_or_null<FullExpr>(NewArg.get())) {
+    if (!isa<ConstantExpr>(E))
+      return E->getSubExpr();
+  }
+  return NewArg;
+}
+
 static void RemoveNestedImmediateInvocation(
     Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec,
     SmallVector<Sema::ImmediateInvocationCandidate, 4>::reverse_iterator It) {
   struct ComplexRemove : TreeTransform<ComplexRemove> {
     using Base = TreeTransform<ComplexRemove>;
     llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
     SmallVector<Sema::ImmediateInvocationCandidate, 4> &IISet;
     SmallVector<Sema::ImmediateInvocationCandidate, 4>::reverse_iterator
struct SimpleRemove : RecursiveASTVisitor<SimpleRemove> {
         return DRSet.size();
       }
     } Visitor(Rec.ReferenceToConsteval);
     Visitor.TraverseStmt(
         Rec.ImmediateInvocationCandidates.front().getPointer()->getSubExpr());
   }
   for (auto CE : Rec.ImmediateInvocationCandidates)
     if (!CE.getInt())
-      EvaluateAndDiagnoseImmediateInvocation(SemaRef, CE);
+      EvaluateAndDiagnoseImmediateInvocation(
+          SemaRef, CE, /*InDefaultArg=*/Rec.isPotentiallyEvaluatedIfUsed());
   for (auto DR : Rec.ReferenceToConsteval) {
     auto *FD = cast<FunctionDecl>(DR->getDecl());
     SemaRef.Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
         << FD;
     SemaRef.Diag(FD->getLocation(), diag::note_declared_at);
   }
 }
 

clang/lib/Sema/SemaExprCXX.cpp

for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
       // particular throw-site.  Lookup will be performed at the catch-site to
       // ensure that the copy constructor is, in fact, accessible (via
       // friendship or any other means).
       Context.addCopyConstructorForExceptionObject(Subobject, CD);
 
       // We don't keep the instantiated default argument expressions around so
       // we must rebuild them here.
       for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
-        if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)))
+        Expr* Dummy;
+        if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I), Dummy))
           return true;
       }
     }
   }
 
   // Under the Itanium C++ ABI, memory for the exception object is allocated by
   // the runtime with no ability for the compiler to request additional
   // alignment. Warn if the exception type requires alignment beyond the minimum

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

assert(Context.getTargetInfo().getCXXABI().isMicrosoft() &&
          Ctor->isDefaultConstructor());
   unsigned NumParams = Ctor->getNumParams();
   if (NumParams == 0)
     return;
   DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
   if (!Attr)
     return;
   for (unsigned I = 0; I != NumParams; ++I) {
+    Expr *Dummy;
     (void)CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
-                                   Ctor->getParamDecl(I));
+                                 Ctor->getParamDecl(I), Dummy);
     CleanupVarDeclMarking();
   }
 }
 
 /// Get the previous declaration of a declaration for the purposes of template
 /// instantiation. If this finds a previous declaration, then the previous
 /// declaration of the instantiation of D should be an instantiation of the
 /// result of this function.

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   E->Param = readDeclAs<ParmVarDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
   E->CXXDefaultArgExprBits.Loc = readSourceLocation();
+  E->CXXDefaultArgExprBits.HasRewrittenArg = Record.readInt();
+  if (E->CXXDefaultArgExprBits.HasRewrittenArg)
+    *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
   E->Field = readDeclAs<FieldDecl>();
   E->UsedContext = readDeclAs<DeclContext>();
   E->CXXDefaultInitExprBits.Loc = readSourceLocation();
 }
case EXPR_CXX_THIS:
       S = new (Context) CXXThisExpr(Empty);
       break;
 
     case EXPR_CXX_THROW:
       S = new (Context) CXXThrowExpr(Empty);
       break;
 
     case EXPR_CXX_DEFAULT_ARG:
-      S = new (Context) CXXDefaultArgExpr(Empty);
+      S = CXXDefaultArgExpr::CreateEmpty(
+          Context,
+          /*HasRewrittenArg*/ Record[ASTStmtReader::NumExprFields]);
       break;
 
     case EXPR_CXX_DEFAULT_INIT:
       S = new (Context) CXXDefaultInitExpr(Empty);
       break;
 
     case EXPR_CXX_BIND_TEMPORARY:
       S = new (Context) CXXBindTemporaryExpr(Empty);

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
   Code = serialization::EXPR_CXX_THROW;
 }
 
 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   Record.AddDeclRef(E->getParam());
   Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
   Record.AddSourceLocation(E->getUsedLocation());
+  Record.push_back(E->hasRewrittenArg());
+  if (E->hasRewrittenArg()) 
+    Record.AddStmt(E->getExpr());
   Code = serialization::EXPR_CXX_DEFAULT_ARG;
 }
 
 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
   Record.AddDeclRef(E->getField());
   Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
   Record.AddSourceLocation(E->getExprLoc());

clang/test/CodeGenCXX/builtin-source-location.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -std=c++2a -fblocks %s -triple x86_64-unknown-unknown -emit-llvm -o %t.ll
 
 // This needs to be performed before #line directives which alter filename
 // RUN: %clang_cc1 -no-opaque-pointers -fno-file-reproducible -fmacro-prefix-map=%p=/UNLIKELY/PATH -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-PREFIX-MAP
 //
 // CHECK-PREFIX-MAP: /UNLIKELY/PATH{{/|\\\\}}builtin-source-location.cpp
 void testRemap() {
   const char *file = __builtin_FILE();
 }
 
 #line 8 "builtin-source-location.cpp"
 
 namespace std {
 class source_location {
 public:
-  static constexpr source_location current(const void *__p = __builtin_source_location()) noexcept {
+  static consteval source_location current(const void *__p = __builtin_source_location()) noexcept {
     source_location __loc;
     __loc.__m_impl = static_cast<const __impl *>(__p);
     return __loc;
   }
-  static source_location bad_current(const void *__p = __builtin_source_location()) noexcept {
+  static constexpr source_location bad_current(const void *__p = __builtin_source_location()) noexcept {
     return current(__p);
   }
   constexpr source_location() = default;
   constexpr source_location(source_location const &) = default;
   constexpr unsigned int line() const noexcept { return __m_impl->_M_line; }
   constexpr unsigned int column() const noexcept { return __m_impl->_M_column; }
   constexpr const char *file() const noexcept { return __m_impl->_M_file_name; }
   constexpr const char *function() const noexcept { return __m_impl->_M_function_name; }

clang/test/SemaCXX/source_location.cpp

 template <class T, class U = SL>
 constexpr Pair<U, U> test_func_template(T, U u = U::current()) {
   static_assert(is_equal(__PRETTY_FUNCTION__, U::current().function()));
   return {u, U::current()};
 }
 template <class T>
 void func_template_tests() {
   constexpr auto P = test_func_template(42);
-  //static_assert(is_equal(P.first.function(), __func__), "");
-  //static_assert(!is_equal(P.second.function(), __func__), "");
+  static_assert(is_equal(P.first.function(), __PRETTY_FUNCTION__), "");
+  static_assert(!is_equal(P.second.function(), __PRETTY_FUNCTION__), "");
 }
 template void func_template_tests<int>();
 
 template <class = int, class T = SL>
 struct TestCtor {
   T info = T::current();
   T ctor_info;
   TestCtor() = default;

clang/test/SemaCXX/source_location_consteval.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+// expected-no-diagnostics
+
+namespace std {
+class source_location {
+  struct __impl;
+
+public:
+  static consteval source_location current(const __impl *__p = __builtin_source_location()) noexcept {
+    source_location __loc;
+    __loc.__m_impl = __p;
+    return __loc;
+  }
+  constexpr source_location() = default;
+  constexpr source_location(source_location const &) = default;
+  constexpr unsigned int line() const noexcept { return __m_impl ? __m_impl->_M_line : 0; }
+  constexpr unsigned int column() const noexcept { return __m_impl ? __m_impl->_M_column : 0; }
+  constexpr const char *file() const noexcept { return __m_impl ? __m_impl->_M_file_name : ""; }
+  constexpr const char *function() const noexcept { return __m_impl ? __m_impl->_M_function_name : ""; }
+
+private:
+  // Note: The type name "std::source_location::__impl", and its constituent
+  // field-names are required by __builtin_source_location().
+  struct __impl {
+    const char *_M_file_name;
+    const char *_M_function_name;
+    unsigned _M_line;
+    unsigned _M_column;
+  };
+  const __impl *__m_impl = nullptr;
+
+public:
+  using public_impl_alias = __impl;
+};
+} // namespace std
+
+using SL = std::source_location;
+
+constexpr bool is_equal(const char *LHS, const char *RHS) {
+  while (*LHS != 0 && *RHS != 0) {
+    if (*LHS != *RHS)
+      return false;
+    ++LHS;
+    ++RHS;
+  }
+  return *LHS == 0 && *RHS == 0;
+}
+
+constexpr SL get_sl(SL l = SL::current()) { return l; }
+SL get_sl_not_const(SL l = SL::current()) { return l; }
+
+#line 700 "CheckDefaultArg.h"
+constexpr SL l = get_sl();
+static_assert(l.line() == 700);
+static_assert(is_equal(l.file(), "CheckDefaultArg.h"));
+
+int test() {
+  static_assert(is_equal(get_sl().function(), __PRETTY_FUNCTION__));
+  static_assert(get_sl().line() ==  __LINE__);
+  return get_sl().line() + get_sl_not_const().line();
+}