Temp __builtin_LINE

docs/LanguageExtensions.rst

   char   __builtin_coro_suspend(bool final)
   bool   __builtin_coro_param(void *original, void *copy)
 
 Note that there is no builtin matching the `llvm.coro.save` intrinsic. LLVM
 automatically will insert one if the first argument to `llvm.coro.suspend` is
 token `none`. If a user calls `__builin_suspend`, clang will insert `token none`
 as the first argument to the intrinsic.
 
+Source location builtins
+------------------------
+
+Clang provides experimental builtins to support C++ standard library implementation
+of `std::experimental::source_location` as specified in  http://wg21.link/N4600.
+With the exception of `__builtin_COLUMN`, these builtins are also implemented by
+GCC.
+
+**Syntax**:
+
+.. code-block:: c
+
+  const char *__builtin_FILE();
+  const char *__builtin_FUNCTION();
+  unsigned    __builtin_LINE();
+  unsigned    __builtin_COLUMN(); // Clang only
+
+**Example of use**:
+
+.. code-block:: c++
+
+  void my_assert(bool pred, int line = __builtin_LINE(), // Captures line of caller
+                 const char* file = __builtin_FILE(),
+                 const char* function = __builtin_FUNCTION()) {
+    if (pred) return;
+    printf("%s:%d assertion failed in function %s\n", file, line, function);
+    std::abort();
+  }
+
+  struct MyAggregateType {
+    int x;
+    int line = __builtin_LINE(); // captures line where aggregate initialization occurs
+  };
+  static_assert(MyAggregateType{42}.line == __LINE__);
+
+  struct MyClassType {
+    int line = __builtin_LINE(); // captures line of the constructor used during initialization
+    constexpr MyClassType(int) { assert(line == __LINE__); }
+  };
+
+**Description**:
+
+The builtins `__builtin_LINE`, `__builtin_FUNCTION`, and `__builtin_FILE` return
+the values, at the "invocation point", for `__LINE__`, `__FUNCTION__`, and
+`__FILE__` respectively. These builtins are constant expressions.
+
+When the builtins appears as part of a default function argument the invocation
+point is the location of the caller. When the builtins appear as part of a
+NSDMI the invocation point is the location of the constructor or
+aggregate initialization used to create the object. Otherwise the invocation
+point is the same as the location of the builtin.
+
+When the invocation point of `__builtin_FUNCTION` is not a function scope the
+empty string is returned.
+
 Non-standard C++11 Attributes
 =============================
 
 Clang's non-standard C++11 attributes live in the ``clang`` attribute
 namespace.
 
 Clang supports GCC's ``gnu`` attribute namespace. All GCC attributes which
 are accepted with the ``__attribute__((foo))`` syntax are also accepted as

include/clang/AST/Expr.h

 
   // Iterators
   child_range children() { return child_range(&Val, &Val+1); }
   const_child_range children() const {
     return const_child_range(&Val, &Val + 1);
   }
 };
 
+/// BuiltinSourceLocExpr - Represents a function call to one of
+/// __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(), or
+/// __BUILTIN_FILE()
+class SourceLocExpr final : public Expr {
+public:
+  enum IdentType { Function, File, Line, Column };
+
+private:
+  SourceLocation BuiltinLoc, RParenLoc;
+  Stmt *Value;
+
+public:
+  SourceLocExpr(IdentType Type, SourceLocation BLoc, SourceLocation RParenLoc,
+                QualType Ty, Expr *E = nullptr);
+
+  /// \brief Build an empty call expression.
+  explicit SourceLocExpr(EmptyShell Empty)
+      : Expr(SourceLocExprClass, Empty), Value(nullptr) {}
+
+  /// \brief Check if an expression contains a SourceLocExpr as a subexpression.
+  static bool containsSourceLocExpr(const Expr *E);
+
+  /// \brief Return a string representing the name of the specific builtin
+  /// function.
+  const char *getBuiltinStr() const LLVM_READONLY;
+
+  IdentType getIdentType() const LLVM_READONLY {
+    return static_cast<IdentType>(SourceLocExprBits.Type);
+  }
+
+  /// \brief If the SourceLocExpr has been resolved return the subexpression
+  /// representing the resolved value. Otherwise return null.
+  const Expr *getSubExpr() const { return cast_or_null<Expr>(Value); }
+  Expr *getSubExpr() { return cast_or_null<Expr>(Value); }
+
+  /// \brief True iff the value for the SourceLocExpr has been determined.
+  bool isUnresolved() const { return Value == nullptr; }
+
+  SourceLocation getLocation() const LLVM_READONLY { return BuiltinLoc; }
+  SourceLocation getLocStart() const LLVM_READONLY { return BuiltinLoc; }
+  SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
+
+  child_range children() {
+    return Value ? child_range(&Value, &Value + 1)
+                 : child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return Value ? const_child_range(&Value, &Value + 1)
+                 : const_child_range(child_iterator(), child_iterator());
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SourceLocExprClass;
+  }
+
+private:
+  friend class ASTStmtReader;
+
+  void setIdentType(IdentType T) { SourceLocExprBits.Type = T; }
+  void setSubExpr(Expr *E) { Value = E; }
+  void setLocStart(SourceLocation L) { BuiltinLoc = L; }
+  void setLocEnd(SourceLocation L) { RParenLoc = L; }
+};
+
 /// @brief Describes an C or C++ initializer list.
 ///
 /// InitListExpr describes an initializer list, which can be used to
 /// initialize objects of different types, including
 /// struct/class/union types, arrays, and vectors. For example:
 ///
 /// @code
 /// struct foo x = { 1, { 2, 3 } };

include/clang/AST/RecursiveASTVisitor.h

 
 DEF_TRAVERSE_STMT(ObjCAvailabilityCheckExpr, {})
 DEF_TRAVERSE_STMT(ParenExpr, {})
 DEF_TRAVERSE_STMT(ParenListExpr, {})
 DEF_TRAVERSE_STMT(PredefinedExpr, {})
 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
 DEF_TRAVERSE_STMT(StmtExpr, {})
+DEF_TRAVERSE_STMT(SourceLocExpr, {})
+
 DEF_TRAVERSE_STMT(UnresolvedLookupExpr, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   if (S->hasExplicitTemplateArgs()) {
     TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
                                               S->getNumTemplateArgs()));
   }
 })
 

include/clang/AST/Stmt.h

protected:
   class CoawaitExprBitfields {
     friend class CoawaitExpr;
 
     unsigned : NumExprBits;
 
     unsigned IsImplicit : 1;
   };
 
+  class SourceLocExprBitfields {
+    friend class SourceLocExpr;
+
+    unsigned : NumExprBits;
+
+    /// \brief The type of source location builtin represented by the
+    /// SourceLocExpr. Ex. __builtin_LINE, __builtin_FUNCTION, ect.
+    unsigned Type : 2;
+  };
+
   union {
     StmtBitfields StmtBits;
     CompoundStmtBitfields CompoundStmtBits;
     IfStmtBitfields IfStmtBits;
     ExprBitfields ExprBits;
     CharacterLiteralBitfields CharacterLiteralBits;
     FloatingLiteralBitfields FloatingLiteralBits;
     UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits;
     DeclRefExprBitfields DeclRefExprBits;
     CastExprBitfields CastExprBits;
     CallExprBitfields CallExprBits;
     ExprWithCleanupsBitfields ExprWithCleanupsBits;
     PseudoObjectExprBitfields PseudoObjectExprBits;
     ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;
     InitListExprBitfields InitListExprBits;
     TypeTraitExprBitfields TypeTraitExprBits;
     CoawaitExprBitfields CoawaitBits;
+    SourceLocExprBitfields SourceLocExprBits;
   };
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
 public:
   // Only allow allocation of Stmts using the allocator in ASTContext
   // or by doing a placement new.

include/clang/Basic/StmtNodes.td

 def ImplicitValueInitExpr : DStmt<Expr>;
 def NoInitExpr : DStmt<Expr>;
 def ArrayInitLoopExpr : DStmt<Expr>;
 def ArrayInitIndexExpr : DStmt<Expr>;
 def ParenListExpr : DStmt<Expr>;
 def VAArgExpr : DStmt<Expr>;
 def GenericSelectionExpr : DStmt<Expr>;
 def PseudoObjectExpr : DStmt<Expr>;
+def SourceLocExpr : DStmt<Expr>;
 
 // Atomic expressions
 def AtomicExpr : DStmt<Expr>;
 
 // GNU Extensions.
 def AddrLabelExpr : DStmt<Expr>;
 def StmtExpr : DStmt<Expr>;
 def ChooseExpr : DStmt<Expr>;

include/clang/Basic/TokenKinds.def

 KEYWORD(_Decimal32                  , KEYALL)
 KEYWORD(_Decimal64                  , KEYALL)
 KEYWORD(_Decimal128                 , KEYALL)
 KEYWORD(__null                      , KEYCXX)
 KEYWORD(__alignof                   , KEYALL)
 KEYWORD(__attribute                 , KEYALL)
 KEYWORD(__builtin_choose_expr       , KEYALL)
 KEYWORD(__builtin_offsetof          , KEYALL)
+KEYWORD(__builtin_FILE              , KEYALL)
+KEYWORD(__builtin_FUNCTION          , KEYALL)
+KEYWORD(__builtin_LINE              , KEYALL)
+KEYWORD(__builtin_COLUMN            , KEYALL)
+
 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
 // type trait.
 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX)
 KEYWORD(__builtin_va_arg            , KEYALL)
 KEYWORD(__extension__               , KEYALL)
 KEYWORD(__float128                  , KEYALL)
 KEYWORD(__imag                      , KEYALL)
 KEYWORD(__int128                    , KEYALL)

include/clang/Sema/Sema.h

   /// in a 'block', this returns the containing context.
   ObjCMethodDecl *getCurMethodDecl();
 
   /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
   /// or C function we're in, otherwise return null.  If we're currently
   /// in a 'block', this returns the containing context.
   NamedDecl *getCurFunctionOrMethodDecl();
 
+  /// getDeclForCurContext - Return the Decl for the current block, lambda,
+  /// captured statement, function, or translation unit.
+  Decl *getDeclForCurContext();
+
   /// Add this decl to the scope shadowed decl chains.
   void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
 
   /// \brief Make the given externally-produced declaration visible at the
   /// top level scope.
   ///
   /// \param D The externally-produced declaration to push.
   ///

                              Expr *RHSExpr, SourceLocation RPLoc);
 
   // __builtin_va_arg(expr, type)
   ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
                         SourceLocation RPLoc);
   ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
                             TypeSourceInfo *TInfo, SourceLocation RPLoc);
 
+  // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
+  // __builtin_COLUMN()
+  ExprResult ActOnSourceLocExpr(Scope *S, SourceLocExpr::IdentType Type,
+                                SourceLocation BuiltinLoc,
+                                SourceLocation RPLoc);
+
+  /// \brief build a potentially resolved SourceLocExpr.
+  ///
+  /// \param SubExpr - null when the SourceLocExpr is unresolved, otherwise
+  /// SubExpr will be a literal expression representing the value of the
+  /// builtin call.
+  ExprResult BuildSourceLocExpr(SourceLocExpr::IdentType Type,
+                                SourceLocation BuiltinLoc, SourceLocation RPLoc,
+                                Expr *SubExpr = nullptr);
+
+  /// \brief Build a SourceLocExpr with a value representing source information
+  /// at the SourceLocation specified by 'AtLoc' and in the context specified
+  /// by 'CurContext'.
+  ///
+  /// \param AtLoc The location at which the builtin should be evaluated.
+  ///
+  /// \param CurContext The context in which the builtin should be evaluated.
+  ExprResult BuildResolvedSourceLocExpr(SourceLocExpr::IdentType Type,
+                                        SourceLocation BuiltinLoc,
+                                        SourceLocation RPLoc,
+                                        SourceLocation AtLoc, Decl *CurContext);
+
+  /// \brief Transform an expression containing unresolved SourceLocExpr's while
+  /// resolving them to the specified `Loc`
+  ExprResult TransformInitContainingSourceLocExpressions(Expr *E,
+                                                         SourceLocation Loc);
+
   // __null
   ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
 
   bool CheckCaseExpression(Expr *E);
 
   /// \brief Describes the result of an "if-exists" condition check.
   enum IfExistsResult {
     /// \brief The symbol exists.

   BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                         NamedDecl *FoundDecl,
                         CXXConstructorDecl *Constructor, bool Elidable,
                         MultiExprArg Exprs, bool HadMultipleCandidates,
                         bool IsListInitialization,
                         bool IsStdInitListInitialization, bool RequiresZeroInit,
                         unsigned ConstructKind, SourceRange ParenRange);
 
+  /// Instantiate or parse a C++ default init expression as necessary.
+  /// Return true on error.
+  bool CheckCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
+
+  /// BuildCXXDefaultInitExpr - Creates a CXXDefaultInitExpr, instantiating
+  /// the default expr if needed.
   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);
 

include/clang/Serialization/ASTBitCodes.h

       /// \brief An AddrLabelExpr record.
       EXPR_ADDR_LABEL,
       /// \brief A StmtExpr record.
       EXPR_STMT,
       /// \brief A ChooseExpr record.
       EXPR_CHOOSE,
       /// \brief A GNUNullExpr record.
       EXPR_GNU_NULL,
+      /// \brief A SourceLocExpr record
+      EXPR_SOURCE_LOC,
       /// \brief A ShuffleVectorExpr record.
       EXPR_SHUFFLE_VECTOR,
       /// \brief A ConvertVectorExpr record.
       EXPR_CONVERT_VECTOR,
       /// \brief BlockExpr
       EXPR_BLOCK,
       /// \brief A GenericSelectionExpr record.
       EXPR_GENERIC_SELECTION,

lib/AST/Expr.cpp

     OO_LessLessEqual, OO_GreaterGreaterEqual,
     OO_AmpEqual, OO_CaretEqual,
     OO_PipeEqual,
     OO_Comma
   };
   return OverOps[Opc];
 }
 
+SourceLocExpr::SourceLocExpr(IdentType Type, SourceLocation BLoc,
+                             SourceLocation RParenLoc, QualType Ty, Expr *E)
+    : Expr(SourceLocExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false,
+           false),
+      BuiltinLoc(BLoc), RParenLoc(RParenLoc), Value(E) {
+  SourceLocExprBits.Type = Type;
+  assert(!Ty->isDependentType() && "Type should never be dependent");
+  assert(!Ty->isArrayType() && "Type should never be an array");
+}
+
+const char *SourceLocExpr::getBuiltinStr() const {
+  switch (getIdentType()) {
+  case File:
+    return "__builtin_FILE";
+  case Function:
+    return "__builtin_FUNCTION";
+  case Line:
+    return "__builtin_LINE";
+  case Column:
+    return "__builtin_COLUMN";
+  }
+}
+
+namespace {
+class CheckForSourceLocVisitor
+    : public ConstStmtVisitor<CheckForSourceLocVisitor, bool> {
+
+public:
+  CheckForSourceLocVisitor() {}
+  bool VisitExpr(const Expr *Node) {
+    return llvm::any_of(Node->children(),
+                        [&](const Stmt *SubStmt) { return Visit(SubStmt); });
+  }
+  bool VisitSourceLocExpr(const SourceLocExpr *SLE) { return true; }
+};
+} // namespace
+
+bool SourceLocExpr::containsSourceLocExpr(const Expr *E) {
+  return CheckForSourceLocVisitor{}.Visit(E);
+}
+
 InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
                            ArrayRef<Expr*> initExprs, SourceLocation rbraceloc)
   : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
          false, false),
     InitExprs(C, initExprs.size()),
     LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(nullptr, true)
 {
   sawArrayRangeDesignator(false);

   case CXXNoexceptExprClass:
   case SizeOfPackExprClass:
   case ObjCStringLiteralClass:
   case ObjCEncodeExprClass:
   case ObjCBoolLiteralExprClass:
   case ObjCAvailabilityCheckExprClass:
   case CXXUuidofExprClass:
   case OpaqueValueExprClass:
+  case SourceLocExprClass:
     // These never have a side-effect.
     return false;
 
   case CallExprClass:
   case CXXOperatorCallExprClass:
   case CXXMemberCallExprClass:
   case CUDAKernelCallExprClass:
   case UserDefinedLiteralClass: {

lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::AsTypeExprClass:
   case Expr::ObjCIndirectCopyRestoreExprClass:
   case Expr::AtomicExprClass:
   case Expr::CXXFoldExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
+  case Expr::SourceLocExprClass:
     return Cl::CL_PRValue;
 
     // Next come the complicated cases.
   case Expr::SubstNonTypeTemplateParmExprClass:
     return ClassifyInternal(Ctx,
                  cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
 
     // C, C++98 [expr.sub]p1: The result is an lvalue of type "T".

lib/AST/ExprConstant.cpp

   bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E)
     { return StmtVisitorTy::Visit(E->getExpr()); }
   bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
     // The initializer may not have been parsed yet, or might be erroneous.
     if (!E->getExpr())
       return Error(E);
     return StmtVisitorTy::Visit(E->getExpr());
   }
+  bool VisitSourceLocExpr(const SourceLocExpr *E) {
+    if (auto *SubE = E->getSubExpr())
+      return StmtVisitorTy::Visit(E->getSubExpr());
+    return Error(E);
+  }
   // We cannot create any objects for which cleanups are required, so there is
   // nothing to do here; all cleanups must come from unevaluated subexpressions.
   bool VisitExprWithCleanups(const ExprWithCleanups *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
 
   bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
     CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
     return static_cast<Derived*>(this)->VisitCastExpr(E);

       if (StopAtNull && !Char.getInt())
         break;
       if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
         return false;
     }
     // Not found: return nullptr.
     return ZeroInitialization(E);
   }
-
   default:
     return visitNonBuiltinCallExpr(E);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Member Pointer Evaluation
 //===----------------------------------------------------------------------===//

     return ICEDiag(IK_NotICE, E->getLocStart());
   }
 
   case Expr::SizeOfPackExprClass:
   case Expr::GNUNullExprClass:
     // GCC considers the GNU __null value to be an integral constant expression.
     return NoDiag();
 
+  case Expr::SourceLocExprClass:
+    return CheckEvalInICE(cast<SourceLocExpr>(E)->getSubExpr(), Ctx);
+
   case Expr::SubstNonTypeTemplateParmExprClass:
     return
       CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
 
   case Expr::ParenExprClass:
     return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
   case Expr::GenericSelectionExprClass:
     return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);

     if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0)
       return FalseResult;
     return TrueResult;
   }
   case Expr::CXXDefaultArgExprClass:
     return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
   case Expr::CXXDefaultInitExprClass:
     return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
-  case Expr::ChooseExprClass: {
+  case Expr::ChooseExprClass:
     return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
   }
-  }
 
   llvm_unreachable("Invalid StmtClass!");
 }
 
 /// Evaluate an expression as a C++11 integral constant expression.
 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
                                                     const Expr *E,
                                                     llvm::APSInt *Value,

lib/AST/ItaniumMangle.cpp

   case Expr::TypeTraitExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
-  {
+  case Expr::SourceLocExprClass: {
     if (!NullOut) {
       // As bad as this diagnostic is, it's better than crashing.
       DiagnosticsEngine &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                        "cannot yet mangle expression type %0");
       Diags.Report(E->getExprLoc(), DiagID)
         << E->getStmtClassName() << E->getSourceRange();
     }

lib/AST/StmtPrinter.cpp

   Indent() << "#pragma omp target teams distribute simd ";
   PrintOMPExecutableDirective(Node);
 }
 
 //===----------------------------------------------------------------------===//
 //  Expr printing methods.
 //===----------------------------------------------------------------------===//
 
+void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
+  OS << Node->getBuiltinStr() << "()";
+}
+
 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
   if (auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
     OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
     return;
   }
   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
     Qualifier->print(OS, Policy);
   if (Node->hasTemplateKeyword())

lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
   VisitExpr(E);  
 }
 
 void StmtProfiler::VisitTypoExpr(const TypoExpr *E) {
   VisitExpr(E);
 }
 
+void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) {
+  VisitExpr(E);
+  if (E->getSubExpr())
+    VisitExpr(E->getSubExpr());
+}
+
 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
   VisitExpr(E);
 }
 

lib/CodeGen/CGExprAgg.cpp

public:
   void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
   void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
     Visit(DAE->getExpr());
   }
   void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
     CodeGenFunction::CXXDefaultInitExprScope Scope(CGF);
     Visit(DIE->getExpr());
   }
+  void VisitSourceLocExpr(SourceLocExpr *SLE) { Visit(SLE->getSubExpr()); }
   void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
   void VisitCXXConstructExpr(const CXXConstructExpr *E);
   void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
   void VisitLambdaExpr(LambdaExpr *E);
   void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
   void VisitExprWithCleanups(ExprWithCleanups *E);
   void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
   void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }

lib/CodeGen/CGExprConstant.cpp

llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
     case CK_FloatingCast:
     case CK_ZeroToOCLEvent:
     case CK_ZeroToOCLQueue:
       return nullptr;
     }
     llvm_unreachable("Invalid CastKind");
   }
 
+  llvm::Constant *VisitSourceLocExpr(SourceLocExpr *SLE, QualType T) {
+    return Visit(SLE->getSubExpr(), T);
+  }
+
   llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE, QualType T) {
     return Visit(DAE->getExpr(), T);
   }
 
   llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
     // No need for a DefaultInitExprScope: we don't handle 'this' in a
     // constant expression.
     return Visit(DIE->getExpr(), T);

lib/CodeGen/CGExprScalar.cpp

public:
   Value *VisitUnaryExtension(const UnaryOperator *E) {
     return Visit(E->getSubExpr());
   }
 
   // C++
   Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
     return EmitLoadOfLValue(E);
   }
-
+  Value *VisitSourceLocExpr(SourceLocExpr *SLE) {
+    return Visit(SLE->getSubExpr());
+  }
   Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
     return Visit(DAE->getExpr());
   }
   Value *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
     CodeGenFunction::CXXDefaultInitExprScope Scope(CGF);
     return Visit(DIE->getExpr());
   }
   Value *VisitCXXThisExpr(CXXThisExpr *TE) {

lib/Parse/ParseExpr.cpp

 /// [MS]    '__FUNCDNAME__'
 /// [MS]    'L__FUNCTION__'
 /// [GNU]   '__PRETTY_FUNCTION__'
 /// [GNU]   '(' compound-statement ')'
 /// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
 /// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
 /// [GNU]   '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
 ///                                     assign-expr ')'
+/// [GNU]   '__builtin_FILE' '(' ')'
+/// [GNU]   '__builtin_FUNCTION' '(' ')'
+/// [GNU]   '__builtin_LINE' '(' ')'
+/// [CLANG] '__builtin_COLUMN' '(' ')'
 /// [GNU]   '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
 /// [GNU]   '__null'
 /// [OBJC]  '[' objc-message-expr ']'
 /// [OBJC]  '\@selector' '(' objc-selector-arg ')'
 /// [OBJC]  '\@protocol' '(' identifier ')'
 /// [OBJC]  '\@encode' '(' type-name ')'
 /// [OBJC]  objc-string-literal
 /// [C++]   simple-type-specifier '(' expression-list[opt] ')'      [C++ 5.2.3]
case tok::kw__Generic:   // primary-expression: generic-selection [C11 6.5.1]
     break;
   case tok::kw___builtin_available:
     return ParseAvailabilityCheckExpr(Tok.getLocation());
   case tok::kw___builtin_va_arg:
   case tok::kw___builtin_offsetof:
   case tok::kw___builtin_choose_expr:
   case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
   case tok::kw___builtin_convertvector:
+  case tok::kw___builtin_COLUMN:
+  case tok::kw___builtin_FILE:
+  case tok::kw___builtin_FUNCTION:
+  case tok::kw___builtin_LINE:
     return ParseBuiltinPrimaryExpression();
   case tok::kw___null:
     return Actions.ActOnGNUNullExpr(ConsumeToken());
 
   case tok::plusplus:      // unary-expression: '++' unary-expression [C99]
   case tok::minusminus: {  // unary-expression: '--' unary-expression [C99]
     // C++ [expr.unary] has:
     //   unary-expression:

 ///
 /// \verbatim
 ///       primary-expression: [C99 6.5.1]
 /// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
 /// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
 /// [GNU]   '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
 ///                                     assign-expr ')'
 /// [GNU]   '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
+/// [GNU]   '__builtin_FILE' '(' ')'
+/// [GNU]   '__builtin_FUNCTION' '(' ')'
+/// [GNU]   '__builtin_LINE' '(' ')'
+/// [CLANG] '__builtin_COLUMN' '(' ')'
 /// [OCL]   '__builtin_astype' '(' assignment-expression ',' type-name ')'
 ///
 /// [GNU] offsetof-member-designator:
 /// [GNU]   identifier
 /// [GNU]   offsetof-member-designator '.' identifier
 /// [GNU]   offsetof-member-designator '[' expression ']'
 /// \endverbatim
 ExprResult Parser::ParseBuiltinPrimaryExpression() {
if (Tok.isNot(tok::r_paren)) {
       SkipUntil(tok::r_paren, StopAtSemi);
       return ExprError();
     }
     
     Res = Actions.ActOnConvertVectorExpr(Expr.get(), DestTy.get(), StartLoc, 
                                          ConsumeParen());
     break;
   }
+  case tok::kw___builtin_COLUMN:
+  case tok::kw___builtin_FILE:
+  case tok::kw___builtin_FUNCTION:
+  case tok::kw___builtin_LINE: {
+    // Attempt to consume the r-paren.
+    if (Tok.isNot(tok::r_paren)) {
+      Diag(Tok, diag::err_expected) << tok::r_paren;
+      SkipUntil(tok::r_paren, StopAtSemi);
+      return ExprError();
+    }
+    SourceLocExpr::IdentType Type = [&] {
+      switch (T) {
+      case tok::kw___builtin_FILE:
+        return SourceLocExpr::File;
+      case tok::kw___builtin_FUNCTION:
+        return SourceLocExpr::Function;
+      case tok::kw___builtin_LINE:
+        return SourceLocExpr::Line;
+      case tok::kw___builtin_COLUMN:
+        return SourceLocExpr::Column;
+      default:
+        llvm_unreachable("invalid keyword");
+      }
+    }();
+    Res = Actions.ActOnSourceLocExpr(getCurScope(), Type, StartLoc,
+                                     ConsumeParen());
+    break;
+  }
   }
 
   if (Res.isInvalid())
     return ExprError();
 
   // These can be followed by postfix-expr pieces because they are
   // primary-expressions.
   return ParsePostfixExpressionSuffix(Res.get());

lib/Sema/Sema.cpp

 
 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
   DeclContext *DC = getFunctionLevelDeclContext();
   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
     return cast<NamedDecl>(DC);
   return nullptr;
 }
 
+Decl *Sema::getDeclForCurContext() {
+  Decl *currentDecl = nullptr;
+  if (const BlockScopeInfo *BSI = getCurBlock())
+    currentDecl = BSI->TheDecl;
+  else if (const LambdaScopeInfo *LSI = getCurLambda())
+    currentDecl = LSI->CallOperator;
+  else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
+    currentDecl = CSI->TheCapturedDecl;
+  else
+    currentDecl = getCurFunctionOrMethodDecl();
+
+  if (!currentDecl)
+    currentDecl = Context.getTranslationUnitDecl();
+  return currentDecl;
+}
+
 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
   // been made more painfully obvious by the refactor that introduced this
   // function, but it is possible that the incoming argument can be
   // eliminated. If it truly cannot be (for example, there is some reentrancy
   // issue I am not seeing yet), then there should at least be a clarifying
   // comment somewhere.

lib/Sema/SemaDeclCXX.cpp

   /// default argument expression.
   class CheckDefaultArgumentVisitor
     : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
     Expr *DefaultArg;
     Sema *S;
 
   public:
     CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
         : DefaultArg(defarg), S(s) {}
 
     bool VisitExpr(Expr *Node);
     bool VisitDeclRefExpr(DeclRefExpr *DRE);
     bool VisitCXXThisExpr(CXXThisExpr *ThisE);
     bool VisitLambdaExpr(LambdaExpr *Lambda);
     bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
   };
 

       return true;
     
     T = ArrayT->getElementType();
   }
   
   return false;
 }
 
+
+static MemInitResult rebuildCtorInit(Sema &SemaRef, BaseAndFieldInfo &Info,
+                                     FieldDecl *Field, Expr *Init) {
+  // assert(!Field->getType()->isDependentType());
+  // assert(!Field->getInClassInitializer()->isTypeDependent());
+  SourceLocation Loc = Info.Ctor->getLocation();
+  ExprResult InitRes =
+      SemaRef.TransformInitContainingSourceLocExpressions(Init, Loc);
+  if (InitRes.isInvalid())
+    return true;
+  return SemaRef.BuildMemberInitializer(Field, InitRes.get(), Loc);
+}
+
 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
                                     FieldDecl *Field, 
                                     IndirectFieldDecl *Indirect = nullptr) {
   if (Field->isInvalidDecl())
     return false;
 
   // Overwhelmingly common case: we have a direct initializer for this field.
   if (CXXCtorInitializer *Init =
-          Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
+          Info.AllBaseFields.lookup(Field->getCanonicalDecl())) {
+    if (SourceLocExpr::containsSourceLocExpr(Init->getInit())) {
+      MemInitResult InitExpr =
+          rebuildCtorInit(SemaRef, Info, Field, Init->getInit());
+      if (InitExpr.isInvalid())
+        return true;
+      Init = InitExpr.get();
+    }
     return Info.addFieldInitializer(Init);
-
+  }
   // C++11 [class.base.init]p8:
   //   if the entity is a non-static data member that has a
   //   brace-or-equal-initializer and either
   //   -- the constructor's class is a union and no other variant member of that
   //      union is designated by a mem-initializer-id or
   //   -- the constructor's class is not a union, and, if the entity is a member
   //      of an anonymous union, no other member of that union is designated by
   //      a mem-initializer-id,
   //   the entity is initialized as specified in [dcl.init].
   //
   // We also apply the same rules to handle anonymous structs within anonymous
   // unions.
   if (Info.isWithinInactiveUnionMember(Field, Indirect))
     return false;
 
   if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
-    ExprResult DIE =
-        SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
-    if (DIE.isInvalid())
+    if (SemaRef.CheckCXXDefaultInitExpr(Info.Ctor->getLocation(), Field))
       return true;
-    CXXCtorInitializer *Init;
-    if (Indirect)
-      Init = new (SemaRef.Context)
-          CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
-                             SourceLocation(), DIE.get(), SourceLocation());
-    else
-      Init = new (SemaRef.Context)
-          CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
-                             SourceLocation(), DIE.get(), SourceLocation());
-    return Info.addFieldInitializer(Init);
+    MemInitResult Init(/*Invalid*/ true);
+
+    if (SourceLocExpr::containsSourceLocExpr(Field->getInClassInitializer()))
+      Init =
+          rebuildCtorInit(SemaRef, Info, Field, Field->getInClassInitializer());
+    else {
+      ExprResult DIE =
+          SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
+      if (DIE.isInvalid())
+        return true;
+      if (Indirect)
+        Init = new (SemaRef.Context)
+            CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
+                               SourceLocation(), DIE.get(), SourceLocation());
+      else
+        Init = new (SemaRef.Context)
+            CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
+                               SourceLocation(), DIE.get(), SourceLocation());
+      assert(!Init.isInvalid());
+    }
+    if (Init.isInvalid())
+      return true;
+    return Info.addFieldInitializer(Init.get());
   }
 
   // Don't initialize incomplete or zero-length arrays.
   if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
     return false;
 
   // Don't try to build an implicit initializer if there were semantic
   // errors in any of the initializers (and therefore we might be

   return CXXConstructExpr::Create(
       Context, DeclInitType, ConstructLoc, Constructor, Elidable,
       ExprArgs, HadMultipleCandidates, IsListInitialization,
       IsStdInitListInitialization, RequiresZeroInit,
       static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
       ParenRange);
 }
 
-ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
+bool Sema::CheckCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   assert(Field->hasInClassInitializer());
-
   // If we already have the in-class initializer nothing needs to be done.
   if (Field->getInClassInitializer())
-    return CXXDefaultInitExpr::Create(Context, Loc, Field);
+    return false;
 
   // If we might have already tried and failed to instantiate, don't try again.
   if (Field->isInvalidDecl())
-    return ExprError();
+    return true;
 
   // Maybe we haven't instantiated the in-class initializer. Go check the
   // pattern FieldDecl to see if it has one.
   CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
 
   if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
     CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
     DeclContext::lookup_result Lookup =

         }
       assert(Pattern && "We must have set the Pattern!");
     }
 
     if (InstantiateInClassInitializer(Loc, Field, Pattern,
                                       getTemplateInstantiationArgs(Field))) {
       // Don't diagnose this again.
       Field->setInvalidDecl();
-      return ExprError();
+      return true;
     }
-    return CXXDefaultInitExpr::Create(Context, Loc, Field);
+    return false;
   }
-
   // DR1351:
   //   If the brace-or-equal-initializer of a non-static data member
   //   invokes a defaulted default constructor of its class or of an
   //   enclosing class in a potentially evaluated subexpression, the
   //   program is ill-formed.
   //
   // This resolution is unworkable: the exception specification of the
   // default constructor can be needed in an unevaluated context, in
   // particular, in the operand of a noexcept-expression, and we can be
   // unable to compute an exception specification for an enclosed class.
   //
   // Any attempt to resolve the exception specification of a defaulted default
   // constructor before the initializer is lexically complete will ultimately
   // come here at which point we can diagnose it.
   RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
   Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
       << OutermostClass << Field;
   Diag(Field->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
   // Recover by marking the field invalid, unless we're in a SFINAE context.
   if (!isSFINAEContext())
     Field->setInvalidDecl();
-  return ExprError();
+  return true;
+}
+
+ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
+  if (CheckCXXDefaultInitExpr(Loc, Field))
+    return ExprError();
+  return CXXDefaultInitExpr::Create(Context, Loc, Field);
 }
 
 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
   if (VD->isInvalidDecl()) return;
 
   CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
   if (ClassDecl->isInvalidDecl()) return;
   if (ClassDecl->hasIrrelevantDestructor()) return;

lib/Sema/SemaExceptionSpec.cpp

   case Expr::NoInitExprClass:
   case Expr::ObjCEncodeExprClass:
   case Expr::ObjCStringLiteralClass:
   case Expr::ObjCBoolLiteralExprClass:
   case Expr::OpaqueValueExprClass:
   case Expr::PredefinedExprClass:
   case Expr::SizeOfPackExprClass:
   case Expr::StringLiteralClass:
+  case Expr::SourceLocExprClass:
     // These expressions can never throw.
     return CT_Cannot;
 
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
     llvm_unreachable("Invalid class for expression");
 
 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:

lib/Sema/SemaExpr.cpp

   (void)success;
   assert(success);
   Target.resize(ResultPtr - &Target[0]);
 }
 
 ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
                                      PredefinedExpr::IdentType IT) {
   // Pick the current block, lambda, captured statement or function.
-  Decl *currentDecl = nullptr;
-  if (const BlockScopeInfo *BSI = getCurBlock())
-    currentDecl = BSI->TheDecl;
-  else if (const LambdaScopeInfo *LSI = getCurLambda())
-    currentDecl = LSI->CallOperator;
-  else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
-    currentDecl = CSI->TheCapturedDecl;
-  else
-    currentDecl = getCurFunctionOrMethodDecl();
-
-  if (!currentDecl) {
+  Decl *currentDecl = getDeclForCurContext();
+  if (currentDecl == Context.getTranslationUnitDecl()) {
     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

       ExprResult ArgE = PerformCopyInitialization(
           Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit);
       if (ArgE.isInvalid())
         return true;
 
       Arg = ArgE.getAs<Expr>();
     } else {
       assert(Param && "can't use default arguments without a known callee");
-
-      ExprResult ArgExpr =
-        BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
+      if (CheckCXXDefaultArgExpr(CallLoc, FDecl, Param))
+        return true;
+      ExprResult ArgExpr = ExprError();
+      if (SourceLocExpr::containsSourceLocExpr(Param->getDefaultArg())) {
+        ArgExpr = TransformInitContainingSourceLocExpressions(
+            Param->getDefaultArg(), CallLoc);
+        if (ArgExpr.isInvalid())
+          return true;
+        InitializedEntity Entity =  InitializedEntity::InitializeParameter(Context,
+                                                                           Param,
+                                                         ProtoArgType);
+        ArgExpr = PerformCopyInitialization(
+          Entity, SourceLocation(), ArgExpr.get(), IsListInitialization, AllowExplicit);
+      } else {
+        ArgExpr = CXXDefaultArgExpr::Create(Context, CallLoc, Param);
+      }
       if (ArgExpr.isInvalid())
         return true;
-
       Arg = ArgExpr.getAs<Expr>();
     }
 
     // Check for array bounds violations for each argument to the call. This
     // check only triggers warnings when the argument isn't a more complex Expr
     // with its own checking, such as a BinaryOperator.
     CheckArrayAccess(Arg);
 

     Ty = Context.LongLongTy;
   else {
     llvm_unreachable("I don't know size of pointer!");
   }
 
   return new (Context) GNUNullExpr(Ty, TokenLoc);
 }
 
+namespace {
+/// A visitor for rebuilding SourceLocExpr's located in default initializers.
+struct RebuildSourceLocExprInInit : public TreeTransform<RebuildSourceLocExprInInit> {
+  typedef TreeTransform<RebuildSourceLocExprInInit> BaseTransform;
+
+  SourceLocation CallerLoc;
+  Decl *CallerDecl;
+
+public:
+  RebuildSourceLocExprInInit(Sema &S, SourceLocation CallerLoc, Decl *CallerDecl)
+      : BaseTransform(S), CallerLoc(CallerLoc), CallerDecl(CallerDecl) {}
+
+  bool AlwaysRebuild() { return true; }
+
+  StmtResult TransformStmt(Stmt *S) {
+    llvm_unreachable("unexpected statement!");
+  }
+
+  ExprResult TransformSourceLocExpr(SourceLocExpr *E) {
+    return SemaRef.BuildResolvedSourceLocExpr(E->getIdentType(),
+                                              E->getLocStart(), E->getLocEnd(),
+                                              CallerLoc, CallerDecl);
+  }
+};
+} // namespace
+
+
+/// Given a function expression of unknown-any type, try to rebuild it
+/// to have a function type.
+ExprResult
+Sema::TransformInitContainingSourceLocExpressions(Expr *Init,
+                                                  SourceLocation Loc) {
+  Decl *currentDecl = getDeclForCurContext();
+  ExprResult Result =
+      RebuildSourceLocExprInInit(*this, Loc, currentDecl).TransformExpr(Init);
+  return Result;
+}
+
+ExprResult Sema::ActOnSourceLocExpr(Scope *S, SourceLocExpr::IdentType Type,
+                                    SourceLocation BuiltinLoc,
+                                    SourceLocation RPLoc) {
+  bool RequiresTransform =
+      // The expression appears within a default argument
+      S->isFunctionPrototypeScope();
+
+  // Check if the expression appears within a NSDMI expression
+  if (S->isClassScope() && !ExprEvalContexts.empty()) {
+    if (auto *VD = dyn_cast_or_null<VarDecl>(
+            ExprEvalContexts.back().ManglingContextDecl))
+      RequiresTransform |= !VD->isStaticDataMember();
+  }
+
+  // SourceLocExpr's appearing in a default function argument or NSDMI can only
+  // be resolved once the location of the caller or constructor which requires
+  // them is known.
+  if (RequiresTransform)
+    return BuildSourceLocExpr(Type, BuiltinLoc, RPLoc);
+  return BuildResolvedSourceLocExpr(Type, BuiltinLoc, RPLoc, BuiltinLoc,
+                                    getDeclForCurContext());
+}
+
+static QualType buildSourceLocType(Sema &S, SourceLocExpr::IdentType Type,
+                                   bool MakeArray = false, int ArraySize = -1) {
+  assert(MakeArray == (ArraySize != -1));
+  bool IsIntType = Type == SourceLocExpr::Line || Type == SourceLocExpr::Column;
+  assert(!IsIntType || (IsIntType && !MakeArray));
+  if (IsIntType)
+    return S.Context.UnsignedIntTy;
+  QualType Ty = S.Context.CharTy;
+  // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
+  if (S.getLangOpts().CPlusPlus || S.getLangOpts().ConstStrings)
+    Ty = Ty.withConst();
+  if (!MakeArray)
+    return S.Context.getPointerType(Ty);
+  return S.Context.getConstantArrayType(Ty, llvm::APInt(32, ArraySize),
+                                        ArrayType::Normal, 0);
+}
+
+ExprResult Sema::BuildResolvedSourceLocExpr(SourceLocExpr::IdentType Type,
+                                            SourceLocation BuiltinLoc,
+                                            SourceLocation RPLoc,
+                                            SourceLocation CallerLoc,
+                                            Decl *CallerDecl) {
+  assert(CallerDecl);
+  PresumedLoc PLoc =
+      SourceMgr.getPresumedLoc(SourceMgr.getExpansionRange(CallerLoc).second);
+  assert(PLoc.isValid()); // FIXME: Learn how to handle this.
+
+  auto CreateString = [&](StringRef SVal) {
+    QualType StrTy = buildSourceLocType(*this, Type,
+                                        /*IsArray*/ true, SVal.size() + 1);
+    StringLiteral *Lit =
+        StringLiteral::Create(Context, SVal, StringLiteral::Ascii,
+                              /*Pascal*/ false, StrTy, CallerLoc);
+    assert(Lit && "should not be null");
+    return Lit;
+  };
+
+  ExprResult Res;
+  switch (Type) {
+  case SourceLocExpr::Column:
+  case SourceLocExpr::Line: {
+    unsigned Value =
+        Type == SourceLocExpr::Line ? PLoc.getLine() : PLoc.getColumn();
+    unsigned MaxWidth = Context.getTargetInfo().getIntWidth();
+    llvm::APInt IntVal(MaxWidth, Value);
+    Res = IntegerLiteral::Create(Context, IntVal, Context.UnsignedIntTy,
+                                 CallerLoc);
+    break;
+  }
+  case SourceLocExpr::File:
+    Res = CreateString(PLoc.getFilename());
+    break;
+  case SourceLocExpr::Function: {
+    if (CallerDecl == Context.getTranslationUnitDecl())
+      Res = CreateString("");
+    else
+      Res = CreateString(
+          PredefinedExpr::ComputeName(PredefinedExpr::Function, CallerDecl));
+    break;
+  }
+  }
+  if (Res.isInvalid())
+    return ExprError();
+  return BuildSourceLocExpr(Type, BuiltinLoc, RPLoc, Res.get());
+}
+
+ExprResult Sema::BuildSourceLocExpr(SourceLocExpr::IdentType Type,
+                                    SourceLocation BuiltinLoc,
+                                    SourceLocation RPLoc, Expr *SubExpr) {
+  // For __builtin_FILE and __builtin_FUNCTION the SubExpr will be a character
+  // array type. Decay this to the pointer type returned by the builtin.
+  if (SubExpr && SubExpr->getType()->isArrayType()) {
+    SubExpr = DefaultFunctionArrayLvalueConversion(SubExpr).get();
+    assert(SubExpr);
+  }
+  return new (Context) SourceLocExpr(Type, BuiltinLoc, RPLoc,
+                                     buildSourceLocType(*this, Type), SubExpr);
+}
+
 bool Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp,
                                               bool Diagnose) {
   if (!getLangOpts().ObjC1)
     return false;
 
   const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
   if (!PT)
     return false;

lib/Sema/SemaInit.cpp

if (FillWithNoInit) {
         ILE->updateInit(SemaRef.Context, Init, Filler);
       return;
     }
     // C++1y [dcl.init.aggr]p7:
     //   If there are fewer initializer-clauses in the list than there are
     //   members in the aggregate, then each member not explicitly initialized
     //   shall be initialized from its brace-or-equal-initializer [...]
     if (Field->hasInClassInitializer()) {
-      ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
+      if (SemaRef.CheckCXXDefaultInitExpr(Loc, Field)) {
+        hadError = true;
+        return;
+      }
+      ExprResult DIE(/*Invalid*/ true);
+      if (SemaRef.CheckCXXDefaultInitExpr(Loc, Field)) {
+        /* nothing todo */
+      } else if (SourceLocExpr::containsSourceLocExpr(
+                     Field->getInClassInitializer())) {
+        DIE = SemaRef.TransformInitContainingSourceLocExpressions(
+            Field->getInClassInitializer(), ILE->getLocStart());
+        if (!DIE.isInvalid())
+          DIE = SemaRef.PerformCopyInitialization(
+              MemberEntity, SourceLocation(), DIE.get(), true, true);
+      } else
+        DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
+
       if (DIE.isInvalid()) {
         hadError = true;
         return;
       }
       if (Init < NumInits)
         ILE->setInit(Init, DIE.get());
       else {
         ILE->updateInit(SemaRef.Context, Init, DIE.get());

lib/Sema/TreeTransform.h

                                    SourceLocation PackLoc,
                                    SourceLocation RParenLoc,
                                    Optional<unsigned> Length,
                                    ArrayRef<TemplateArgument> PartialArgs) {
     return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
                                   RParenLoc, Length, PartialArgs);
   }
 
+  /// \brief Build a new expression representing a call to a source location
+  ///  builtin.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentType Type,
+                                  SourceLocation BuiltinLoc,
+                                  SourceLocation RPLoc,
+                                  Expr *SubExpr = nullptr) {
+    return getSema().BuildSourceLocExpr(Type, BuiltinLoc, RPLoc, SubExpr);
+  }
+
   /// \brief Build a new Objective-C boxed expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
     return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
   }
 

   // Transform arguments.
   bool ArgChanged = false;
   SmallVector<Expr*, 8> Args;
   if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                   &ArgChanged))
     return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
-      Callee.get() == E->getCallee() &&
-      !ArgChanged)
+      Callee.get() == E->getCallee() && !ArgChanged)
     return SemaRef.MaybeBindToTemporary(E);
 
   // FIXME: Wrong source location information for the '('.
   SourceLocation FakeLParenLoc
     = ((Expr *)Callee.get())->getSourceRange().getBegin();
   return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                       Args,
                                       E->getRParenLoc());

 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
   return getDerived().TransformCallExpr(E);
 }
 
+template <typename Derived>
+ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
+  Expr *SubExpr = E->getSubExpr();
+  if (SubExpr) {
+    ExprResult Res = getDerived().TransformExpr(SubExpr);
+    if (Res.isInvalid())
+      return ExprError();
+    SubExpr = Res.get();
+  }
+  bool SubExprChanged = SubExpr && SubExpr != E->getSubExpr()->IgnoreImpCasts();
+  if (!getDerived().AlwaysRebuild() && !SubExprChanged)
+    return E;
+  return getDerived().RebuildSourceLocExpr(E->getIdentType(), E->getLocStart(),
+                                           E->getLocEnd(), SubExpr);
+}
+
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
   // Transform the callee.
   ExprResult Callee = getDerived().TransformExpr(E->getCallee());
   if (Callee.isInvalid())
     return ExprError();
 

 ExprResult
 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   ParmVarDecl *Param
     = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
                                                            E->getParam()));
   if (!Param)
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      Param == E->getParam())
+  if (!getDerived().AlwaysRebuild() && Param == E->getParam())
     return E;
 
   return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {

lib/Serialization/ASTReaderStmt.cpp

   VisitExpr(E);
   E->setSubExpr(Record.readSubExpr());
   E->setWrittenTypeInfo(GetTypeSourceInfo());
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
   E->setIsMicrosoftABI(Record.readInt());
 }
 
+void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
+  VisitExpr(E);
+  E->setSubExpr(Record.readSubExpr());
+  E->setLocStart(ReadSourceLocation());
+  E->setLocEnd(ReadSourceLocation());
+  E->setIdentType(static_cast<SourceLocExpr::IdentType>(Record.readInt()));
+}
+
 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
   VisitExpr(E);
   E->setAmpAmpLoc(ReadSourceLocation());
   E->setLabelLoc(ReadSourceLocation());
   E->setLabel(ReadDeclAs<LabelDecl>());
 }
 
 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {

     case EXPR_ARRAY_INIT_INDEX:
       S = new (Context) ArrayInitIndexExpr(Empty);
       break;
 
     case EXPR_VA_ARG:
       S = new (Context) VAArgExpr(Empty);
       break;
 
+    case EXPR_SOURCE_LOC:
+      S = new (Context) SourceLocExpr(Empty);
+      break;
+
     case EXPR_ADDR_LABEL:
       S = new (Context) AddrLabelExpr(Empty);
       break;
 
     case EXPR_STMT:
       S = new (Context) StmtExpr(Empty);
       break;
 

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
   Record.AddStmt(E->getSubExpr());
   Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
   Record.AddSourceLocation(E->getBuiltinLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Record.push_back(E->isMicrosoftABI());
   Code = serialization::EXPR_VA_ARG;
 }
 
+void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
+  VisitExpr(E);
+  Record.AddStmt(E->getSubExpr());
+  Record.AddSourceLocation(E->getLocStart());
+  Record.AddSourceLocation(E->getLocEnd());
+  Record.push_back(E->getIdentType());
+  Code = serialization::EXPR_SOURCE_LOC;
+}
+
 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getAmpAmpLoc());
   Record.AddSourceLocation(E->getLabelLoc());
   Record.AddDeclRef(E->getLabel());
   Code = serialization::EXPR_ADDR_LABEL;
 }
 

lib/StaticAnalyzer/Core/ExprEngine.cpp

     case Stmt::CXXScalarValueInitExprClass:
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::ObjCBoolLiteralExprClass:
     case Stmt::ObjCAvailabilityCheckExprClass:
     case Stmt::FloatingLiteralClass:
     case Stmt::NoInitExprClass:
     case Stmt::SizeOfPackExprClass:
     case Stmt::StringLiteralClass:
+    case Stmt::SourceLocExprClass:
     case Stmt::ObjCStringLiteralClass:
     case Stmt::CXXPseudoDestructorExprClass:
     case Stmt::SubstNonTypeTemplateParmExprClass:
     case Stmt::CXXNullPtrLiteralExprClass:
     case Stmt::OMPArraySectionExprClass:
     case Stmt::TypeTraitExprClass: {
       Bldr.takeNodes(Pred);
       ExplodedNodeSet preVisit;

test/CodeGenCXX/builtin_FUNCTION.cpp

+// RUN: %clang_cc1 -std=c++1z -fblocks %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+namespace test_func {
+
+constexpr const char *test_default_arg(const char *f = __builtin_FUNCTION()) {
+  return f;
+}
+// CHECK: @[[EMPTY_STR:.+]] = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+
+// CHECK: @_ZN9test_func6globalE = global i8* getelementptr inbounds ([1 x i8], [1 x i8]* @[[EMPTY_STR]], i32 0, i32 0), align 8
+const char *global = test_default_arg();
+
+// CHECK: @_ZN9test_func10global_twoE = global i8* getelementptr inbounds ([1 x i8], [1 x i8]* @[[EMPTY_STR]], i32 0, i32 0), align 8
+const char *global_two = __builtin_FUNCTION();
+
+// CHECK: @[[STR_ONE:.+]] = private unnamed_addr constant [14 x i8] c"test_func_one\00", align 1
+// CHECK: @[[STR_TWO:.+]] = private unnamed_addr constant [14 x i8] c"test_func_two\00", align 1
+// CHECK: @[[STR_THREE:.+]] = private unnamed_addr constant [20 x i8] c"do_default_arg_test\00", align 1
+
+// CHECK: define i8* @_ZN9test_func13test_func_oneEv()
+// CHECK: ret i8* getelementptr inbounds ([14 x i8], [14 x i8]* @[[STR_ONE]], i32 0, i32 0)
+const char *test_func_one() {
+  return __builtin_FUNCTION();
+}
+
+// CHECK: define i8* @_ZN9test_func13test_func_twoEv()
+// CHECK: ret i8* getelementptr inbounds ([14 x i8], [14 x i8]* @[[STR_TWO]], i32 0, i32 0)
+const char *test_func_two() {
+  return __builtin_FUNCTION();
+}
+
+// CHECK: define void @_ZN9test_func19do_default_arg_testEv()
+// CHECK: %call = call i8* @_ZN9test_func16test_default_argEPKc(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @[[STR_THREE]], i32 0, i32 0))
+void do_default_arg_test() {
+  test_default_arg();
+}
+
+template <class>
+void test_template(const char *f = __builtin_FUNCTION()) {
+  (void)__builtin_FUNCTION();
+}
+void do_template_test() {
+  test_template<int>();
+}
+} // namespace test_func

test/CodeGenCXX/builtin_LINE.cpp

+// RUN: %clang_cc1 -std=c++1z -fblocks %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+extern "C" int sink;
+struct Tag1 {};
+struct Tag2 {};
+struct Tag3 {};
+struct Tag4 {};
+
+constexpr int get_line_constexpr(int l = __builtin_LINE()) {
+  return l;
+}
+
+// CHECK: @global_one = global i32 [[@LINE+1]], align 4
+int global_one = __builtin_LINE();
+// CHECK-NEXT: @global_two = global i32 [[@LINE+1]], align 4
+int global_two = get_line_constexpr();
+
+struct InClassInit {
+  int Init = __builtin_LINE();
+  InClassInit() = default;
+  constexpr InClassInit(Tag1, int l = __builtin_LINE()) : Init(l) {}
+  constexpr InClassInit(Tag2) : Init(__builtin_LINE()) {}
+  InClassInit(Tag3, int l = __builtin_LINE()) : Init(l) {}
+  InClassInit(Tag4) : Init(__builtin_LINE()) {}
+
+  static void test_class();
+};
+// CHECK-LABEL: define void @_ZN11InClassInit10test_classEv()
+void InClassInit::test_class() {
+  // CHECK: call void @_ZN11InClassInitC1Ev(%struct.InClassInit* %test_one)
+  InClassInit test_one;
+  // CHECK-NEXT: call void @_ZN11InClassInitC1E4Tag1i(%struct.InClassInit* %test_two, i32 [[@LINE+1]])
+  InClassInit test_two{Tag1{}};
+  // CHECK-NEXT: call void @_ZN11InClassInitC1E4Tag2(%struct.InClassInit* %test_three)
+  InClassInit test_three{Tag2{}};
+  // CHECK-NEXT: call void @_ZN11InClassInitC1E4Tag3i(%struct.InClassInit* %test_four, i32 [[@LINE+1]])
+  InClassInit test_four(Tag3{});
+  // CHECK-NEXT: call void @_ZN11InClassInitC1E4Tag4(%struct.InClassInit* %test_five)
+  InClassInit test_five{Tag4{}};
+}
+
+int get_line(int l = __builtin_LINE()) {
+  return l;
+}
+
+// CHECK-LABEL: define void @_Z13get_line_testv()
+void get_line_test() {
+  // CHECK: %[[CALL:.+]] = call i32 @_Z8get_linei(i32 [[@LINE+2]])
+  // CHECK-NEXT: store i32 %[[CALL]], i32* @sink, align 4
+  sink = get_line();
+  // CHECK-NEXT:  store i32 [[@LINE+1]], i32* @sink, align 4
+  sink = __builtin_LINE();
+}

test/CodeGenCXX/debug-info-line.cpp

 // CHECK-LABEL: define
 void f24_a(__complex float = complex_src());
 void f24() {
 // CHECK: call {{.*}}complex_src{{.*}}, !dbg [[DBG_F24:![0-9]*]]
 #line 2600
   f24_a();
 }
 
+// CHECK-LABEL: define
+void f25_a(int x = __builtin_LINE()) {}
+void f25() {
+  // CHECK: call void @_Z5f25_ai(i32 2700)
+#line 2700
+  f25_a();
+}
 // CHECK: [[DBG_F1]] = !DILocation(line: 100,
 // CHECK: [[DBG_FOO_VALUE]] = !DILocation(line: 200,
 // CHECK: [[DBG_FOO_REF]] = !DILocation(line: 202,
 // CHECK: [[DBG_FOO_COMPLEX]] = !DILocation(line: 204,
 // CHECK: [[DBG_F2]] = !DILocation(line: 300,
 // CHECK: [[DBG_F3]] = !DILocation(line: 400,
 // CHECK: [[DBG_F4]] = !DILocation(line: 500,
 // CHECK: [[DBG_F5]] = !DILocation(line: 600,

test/Parser/builtin_source_location.c

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int main() {
+  int line = __builtin_LINE();
+  __builtin_LINE(42); // expected-error {{expected ')'}}
+  __builtin_LINE(double); // expected-error {{expected ')'}}
+
+  int column = __builtin_COLUMN();
+  __builtin_COLUMN(42); // expected-error {{expected ')'}}
+  __builtin_COLUMN(double); // expected-error {{expected ')'}}
+
+  const char *func = __builtin_FUNCTION();
+  __builtin_FUNCTION(42); // expected-error {{expected ')'}}
+  __builtin_FUNCTION(double); // expected-error {{expected ')'}}
+
+  const char *file = __builtin_FILE();
+  __builtin_FILE(42); // expected-error {{expected ')'}}
+  __builtin_FILE(double); // expected-error {{expected ')'}}
+}

test/Sema/source_location.c

+// RUN: %clang_cc1 -std=c90 -fconst-strings -DCONST_STRINGS -verify %s
+// RUN: %clang_cc1 -std=c90 -verify %s
+
+// expected-no-diagnostics
+
+#define IsEqual(L, R) (__builtin_strcmp(L, R) == 0)
+
+const char *const FILE = __builtin_FILE();
+const char *const FUNC = __builtin_FUNCTION();
+const unsigned LINE = __builtin_LINE();
+const unsigned COL = __builtin_COLUMN();
+
+#ifndef CONST_STRINGS
+char *const NCFILE = __builtin_FILE();
+char *const NCFUNC = __builtin_FUNCTION();
+#endif
+
+#ifdef CONST_STRINGS
+_Static_assert(IsEqual(__builtin_FILE(), __FILE__), "");
+_Static_assert(__builtin_LINE() == __LINE__, "");
+_Static_assert(IsEqual("", __builtin_FUNCTION()), "");
+
+#line 42 "my_file.c"
+_Static_assert(__builtin_LINE() == 42, "");
+_Static_assert(IsEqual(__builtin_FILE(), "my_file.c"), "");
+
+_Static_assert(__builtin_COLUMN() == __builtin_strlen("_Static_assert(_"), "");
+
+void foo() {
+  _Static_assert(IsEqual(__builtin_FUNCTION(), "foo"), "");
+}
+#endif // CONST_STRINGS

test/SemaCXX/Inputs/source-location-file.h

+
+// NOTE: source_location.cpp must include this file after defining
+// std::source_location.
+namespace source_location_file {
+
+constexpr const char *FILE = __FILE__;
+constexpr SL global_info = SL::current();
+
+constexpr SL test_function(SL v = SL::current()) {
+  return v;
+}
+
+constexpr SL test_function_indirect() {
+  return test_function();
+}
+
+template <class T, class U = SL>
+constexpr U test_function_template(T, U u = U::current()) {
+  return u;
+}
+
+template <class T, class U = SL>
+constexpr U test_function_template_indirect(T t) {
+  return test_function_template(t);
+}
+
+struct TestClass {
+  SL info = SL::current();
+  SL ctor_info;
+  TestClass() = default;
+  constexpr TestClass(int, SL cinfo = SL::current()) : ctor_info(cinfo) {}
+  template <class T, class U = SL>
+  constexpr TestClass(int, T, U u = U::current()) : ctor_info(u) {}
+};
+
+template <class T = SL>
+struct AggrClass {
+  int x;
+  T info;
+  T init_info = T::current();
+};
+
+} // namespace source_location_file

test/SemaCXX/source_location.cpp

+// RUN: %clang_cc1 -std=c++1z -fcxx-exceptions -fexceptions -verify %s
+// expected-no-diagnostics
+
+#define assert(...) ((__VA_ARGS__) ? ((void)0) : throw 42)
+#define CURRENT_FROM_MACRO() SL::current()
+#define FORWARD(...) __VA_ARGS__
+
+namespace std {
+namespace experimental {
+struct source_location {
+private:
+  unsigned int __m_line = 0;
+  unsigned int __m_col = 0;
+  const char *__m_file = nullptr;
+  const char *__m_func = nullptr;
+public:
+  static constexpr source_location current(
+      const char *__file = __builtin_FILE(),
+      const char *__func = __builtin_FUNCTION(),
+      unsigned int __line = __builtin_LINE(),
+      unsigned int __col = __builtin_COLUMN()) noexcept {
+    source_location __loc;
+    __loc.__m_line = __line;
+    __loc.__m_col = __col;
+    __loc.__m_file = __file;
+    __loc.__m_func = __func;
+    return __loc;
+  }
+  constexpr source_location() = default;
+  constexpr source_location(source_location const &) = default;
+  constexpr unsigned int line() const noexcept { return __m_line; }
+  constexpr unsigned int column() const noexcept { return __m_col; }
+  constexpr const char *file() const noexcept { return __m_file; }
+  constexpr const char *function() const noexcept { return __m_func; }
+};
+} // namespace experimental
+} // namespace std
+
+using SL = std::experimental::source_location;
+
+#include "Inputs/source-location-file.h"
+namespace SLF = source_location_file;
+
+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;
+}
+
+template <class T>
+constexpr T identity(T t) {
+  return t;
+}
+
+template <class T, class U>
+struct Pair {
+  T first;
+  U second;
+};
+
+template <class T, class U>
+constexpr bool is_same = false;
+template <class T>
+constexpr bool is_same<T, T> = true;
+
+// test types
+static_assert(is_same<decltype(__builtin_LINE()), unsigned>);
+static_assert(is_same<decltype(__builtin_COLUMN()), unsigned>);
+static_assert(is_same<decltype(__builtin_FILE()), const char *>);
+static_assert(is_same<decltype(__builtin_FUNCTION()), const char *>);
+
+// test noexcept
+static_assert(noexcept(__builtin_LINE()));
+static_assert(noexcept(__builtin_COLUMN()));
+static_assert(noexcept(__builtin_FILE()));
+static_assert(noexcept(__builtin_FUNCTION()));
+
+//===----------------------------------------------------------------------===//
+//                            __builtin_LINE()
+//===----------------------------------------------------------------------===//
+
+namespace test_line {
+
+static_assert(SL::current().line() == __LINE__);
+static_assert(SL::current().line() == CURRENT_FROM_MACRO().line());
+
+static constexpr SL GlobalS = SL::current();
+
+static_assert(GlobalS.line() == __LINE__ - 2);
+
+// clang-format off
+constexpr bool test_line_fn() {
+  constexpr SL S = SL::current();
+  static_assert(S.line() == (__LINE__ - 1), "");
+  // The start of the call expression to `current()` begins at the token `SL`
+  constexpr int ExpectLine = __LINE__ + 3;
+  constexpr SL S2
+  =
+  SL // Call expression starts here
+  ::
+  current
+  (
+
+  )
+  ;
+  static_assert(S2.line() == ExpectLine, "");
+
+  static_assert(
+          FORWARD(
+             __builtin_LINE
+            (
+            )
+          )
+    == __LINE__ - 1, "");
+  static_assert(\
+\
+  __builtin_LINE()\
+\
+  == __LINE__ - 2, "");
+  static_assert(\
+          _\
+_builtin_LINE()
+          == __LINE__ - 2, "");
+
+  return true;
+}
+// clang-format on
+static_assert(test_line_fn());
+
+static_assert(__builtin_LINE() == __LINE__, "");
+
+constexpr int baz() { return 101; }
+
+constexpr int test_line_fn_simple(int z = baz(), int x = __builtin_LINE()) {
+  return x;
+}
+void bar() {
+  static_assert(test_line_fn_simple() == __LINE__, "");
+  static_assert(test_line_fn_simple() == __LINE__, "");
+}
+
+template <class T>
+constexpr bool test_line_fn_template(T Expect, int L = __builtin_LINE()) {
+  return Expect == L;
+}
+static_assert(test_line_fn_template(__LINE__));
+
+struct InMemInit {
+  constexpr bool check(int expect) const {
+    return info.line() == expect;
+  }
+  SL info = SL::current();
+  InMemInit() = default;
+  constexpr InMemInit(int) {}
+};
+static_assert(InMemInit{}.check(__LINE__ - 3), "");
+static_assert(InMemInit{42}.check(__LINE__ - 3), "");
+
+template <class T, class U = SL>
+struct InMemInitTemplate {
+  constexpr bool check(int expect) const {
+    return info.line() == expect;
+  }
+  U info = U::current();
+  InMemInitTemplate() = default;
+  constexpr InMemInitTemplate(T) {}
+  constexpr InMemInitTemplate(T, T) : info(U::current()) {}
+  template <class V = U> constexpr InMemInitTemplate(T, T, T, V info = U::current())
+      : info(info) {}
+};
+void test_mem_init_template() {
+  constexpr int line_offset = 8;
+  static_assert(InMemInitTemplate<int>{}.check(__LINE__ - line_offset), "");
+  static_assert(InMemInitTemplate<unsigned>{42}.check(__LINE__ - line_offset), "");
+  static_assert(InMemInitTemplate<unsigned>{42, 42}.check(__LINE__ - line_offset), "");
+  static_assert(InMemInitTemplate<unsigned>{42, 42, 42}.check(__LINE__), "");
+}
+
+struct AggInit {
+  int x;
+  int y = __builtin_LINE();
+  constexpr bool check(int expect) const {
+    return y == expect;
+  }
+};
+constexpr AggInit AI{42};
+static_assert(AI.check(__LINE__ - 1), "");
+
+template <class T, class U = SL>
+struct AggInitTemplate {
+  constexpr bool check(int expect) const {
+    return expect == info.line();
+  }
+  T x;
+  U info = U::current();
+};
+
+template <class T, class U = SL>
+constexpr U test_fn_template(T, U u = U::current()) {
+  return u;
+}
+void fn_template_tests() {
+  static_assert(test_fn_template(42).line() == __LINE__, "");
+}
+
+struct TestMethodTemplate {
+  template <class T, class U = SL, class U2 = SL>
+  constexpr U get(T, U u = U::current(), U2 u2 = identity(U2::current())) const {
+    assert(u.line() == u2.line());
+    return u;
+  }
+};
+void method_template_tests() {
+  static_assert(TestMethodTemplate{}.get(42).line() == __LINE__, "");
+}
+
+struct InStaticInit {
+  static constexpr int LINE = __LINE__;
+  static constexpr const int x1 = __builtin_LINE();
+  static constexpr const int x2 = identity(__builtin_LINE());
+  static const int x3;
+  const int x4 = __builtin_LINE();
+  int x5 = __builtin_LINE();
+};
+const int InStaticInit::x3 = __builtin_LINE();
+static_assert(InStaticInit::x1 == InStaticInit::LINE + 1, "");
+static_assert(InStaticInit::x2 == InStaticInit::LINE + 2, "");
+
+template <class T, int N = __builtin_LINE(), int Expect = -1>
+constexpr void check_fn_template_param(T) {
+  constexpr int RealExpect = Expect == -1 ? __LINE__ - 2 : Expect;
+  static_assert(N == RealExpect);
+}
+template void check_fn_template_param(int);
+template void check_fn_template_param<long, 42, 42>(long);
+
+} // namespace test_line
+
+//===----------------------------------------------------------------------===//
+//                            __builtin_FILE()
+//===----------------------------------------------------------------------===//
+
+namespace test_file {
+constexpr const char *test_file_simple(const char *__f = __builtin_FILE()) {
+  return __f;
+}
+void test_function() {
+  static_assert(is_equal(test_file_simple(), __FILE__));
+  static_assert(is_equal(SLF::test_function().file(), __FILE__), "");
+  static_assert(is_equal(SLF::test_function_template(42).file(), __FILE__), "");
+
+  static_assert(is_equal(SLF::test_function_indirect().file(), SLF::global_info.file()), "");
+  static_assert(is_equal(SLF::test_function_template_indirect(42).file(), SLF::global_info.file()), "");
+
+  static_assert(test_file_simple() != nullptr);
+  static_assert(!is_equal(test_file_simple(), "source_location.cpp"));
+}
+void test_class() {
+  using SLF::TestClass;
+  constexpr TestClass Default;
+  constexpr TestClass InParam{42};
+  constexpr TestClass Template{42, 42};
+  static_assert(is_equal(Default.info.file(), SLF::FILE), "");
+  static_assert(is_equal(InParam.info.file(), SLF::FILE), "");
+  static_assert(is_equal(InParam.ctor_info.file(), __FILE__), "");
+}
+
+void test_aggr_class() {
+  using Agg = SLF::AggrClass<>;
+  constexpr Agg Default{};
+  constexpr Agg InitOne{42};
+  static_assert(is_equal(Default.init_info.file(), __FILE__), "");
+  static_assert(is_equal(InitOne.init_info.file(), __FILE__), "");
+}
+
+} // namespace test_file
+
+//===----------------------------------------------------------------------===//
+//                            __builtin_FUNCTION()
+//===----------------------------------------------------------------------===//
+
+namespace test_func {
+
+constexpr const char *test_func_simple(const char *__f = __builtin_FUNCTION()) {
+  return __f;
+}
+constexpr const char *get_function() {
+  return __func__;
+}
+constexpr bool test_function() {
+  return is_equal(__func__, test_func_simple()) &&
+         !is_equal(get_function(), test_func_simple());
+}
+static_assert(test_function());
+
+template <class T, class U = SL>
+constexpr Pair<U, U> test_func_template(T, U u = U::current()) {
+  static_assert(is_equal(__func__, 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__), "");
+}
+template void func_template_tests<int>();
+
+template <class = int, class T = SL>
+struct TestCtor {
+  T info = T::current();
+  T ctor_info;
+  TestCtor() = default;
+  template <class U = SL>
+  constexpr TestCtor(int, U u = U::current()) : ctor_info(u) {}
+};
+void ctor_tests() {
+  constexpr TestCtor<> Default;
+  constexpr TestCtor<> Template{42};
+  static_assert(!is_equal(Default.info.function(), __func__));
+  static_assert(is_equal(Default.info.function(), "TestCtor"));
+  static_assert(is_equal(Template.info.function(), "TestCtor"));
+  static_assert(is_equal(Template.ctor_info.function(), __func__));
+}
+
+constexpr SL global_sl = SL::current();
+static_assert(is_equal(global_sl.function(), ""));
+
+} // namespace test_func
+
+//===----------------------------------------------------------------------===//
+//                            __builtin_COLUMN()
+//===----------------------------------------------------------------------===//
+
+namespace test_column {
+
+// clang-format off
+constexpr bool test_column_fn() {
+  constexpr SL S = SL::current();
+  static_assert(S.line() == (__LINE__ - 1), "");
+  constexpr int Indent = 4;
+  {
+    // The start of the call expression to `current()` begins at the token `SL`
+    constexpr int ExpectCol = Indent + 3;
+    constexpr SL S2
+     =
+      SL // Call expression starts here
+        ::
+          current
+                 (
+
+                  )
+                   ;
+    static_assert(S2.column() == ExpectCol, "");
+  }
+  {
+    constexpr int ExpectCol = 2;
+    constexpr int C =
+ __builtin_COLUMN // Expect call expression to start here
+      ();
+    static_assert(C == ExpectCol);
+  }
+  return true;
+}
+
+static_assert(test_column_fn());
+
+// Test that the column matches the start of the call expression 'SL::current()'
+static_assert(SL::current().column() == __builtin_strlen("static_assert(S"));
+struct TestClass {
+  int x = __builtin_COLUMN();
+   TestClass() = default; /* indented to 3 spaces for testing */
+  constexpr TestClass(int, int o = __builtin_COLUMN()) : x(o) {}
+};
+struct TestAggClass {
+  int x = __builtin_COLUMN();
+};
+constexpr bool test_class() {
+
+  auto check = [](int V, const char* S, int indent = 4) {
+    assert(V == (__builtin_strlen(S) + indent));
+  };
+  {
+    TestClass t{};
+    check(t.x, "   T", 0); // Start of default constructor decl.
+  }
+  {
+    TestClass t1
+            {42};
+    check(t1.x, "TestClass t"); // Start of variable being constructed.
+  }
+  {
+    TestAggClass t  {};
+    check(t.x, "TestAggClass t  {");
+  }
+  {
+    TestAggClass t = {};
+    check(t.x, "TestAggClass t = {");
+  }
+  return true;
+}
+static_assert(test_class());
+// clang-format on
+} // namespace test_column
+
+// Test [reflection.src_loc.creation]p2
+//  >  The value should be affected by #line (C++14 16.4) in the same manner as
+//  >  for __LINE__ and __FILE__.
+namespace test_pragma_line {
+constexpr int StartLine = 42;
+#line 42
+static_assert(__builtin_LINE() == StartLine);
+static_assert(__builtin_LINE() == StartLine + 1);
+static_assert(SL::current().line() == StartLine + 2);
+#line 44 "test_file.c"
+static_assert(is_equal("test_file.c", __FILE__));
+static_assert(is_equal("test_file.c", __builtin_FILE()));
+static_assert(is_equal("test_file.c", SL::current().file()));
+static_assert(is_equal("test_file.c", SLF::test_function().file()));
+static_assert(is_equal(SLF::FILE, SLF::test_function_indirect().file()));
+} // end namespace test_pragma_line