[clang] Provide source range to 'invalid subexpr in const expr' diags

[aaron.ballman]

LGTM!

clang/lib/AST/ExprConstant.cpp

if (const Expr *E = dyn_cast<Expr>(S)) {
         // VisitExprWithCleanups should create one when necessary.
         FullExpressionRAII Scope(Info);
         if (!EvaluateIgnoredValue(Info, E) || !Scope.destroy())
           return ESR_Failed;
       }
       return ESR_Succeeded;
     }
 
-    Info.FFDiag(S->getBeginLoc());
+    Info.FFDiag(S->getBeginLoc()) << S->getSourceRange();
     return ESR_Failed;
 
   case Stmt::NullStmtClass:
     return ESR_Succeeded;
 
   case Stmt::DeclStmtClass: {
     const DeclStmt *DS = cast<DeclStmt>(S);
     for (const auto *D : DS->decls()) {

 public:
   ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
 
   EvalInfo &getEvalInfo() { return Info; }
 
   /// Report an evaluation error. This should only be called when an error is
   /// first discovered. When propagating an error, just return false.
   bool Error(const Expr *E, diag::kind D) {
-    Info.FFDiag(E, D);
+    Info.FFDiag(E, D) << E->getSourceRange();
     return false;
   }
   bool Error(const Expr *E) {
     return Error(E, diag::note_invalid_subexpr_in_const_expr);
   }
 
   bool VisitStmt(const Stmt *) {
     llvm_unreachable("Expression evaluator should not be called on stmts");

clang/lib/AST/Interp/Interp.h

inline bool GetFnPtr(InterpState &S, CodePtr OpPC, const Function *Func) {
   S.Stk.push<FunctionPointer>(Func);
   return true;
 }
 
 /// Just emit a diagnostic. The expression that caused emission of this
 /// op is not valid in a constant context.
 inline bool Invalid(InterpState &S, CodePtr OpPC) {
   const SourceLocation &Loc = S.Current->getLocation(OpPC);
-  S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+  S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr)
+      << S.Current->getRange(OpPC);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Read opcode arguments
 //===----------------------------------------------------------------------===//
 
 template <typename T> inline T ReadArg(InterpState &S, CodePtr &OpPC) {

clang/lib/AST/Interp/InterpFrame.h

public:
 
   /// Returns the return address of the frame.
   CodePtr getRetPC() const { return RetPC; }
 
   /// Map a location to a source.
   virtual SourceInfo getSource(CodePtr PC) const;
   const Expr *getExpr(CodePtr PC) const;
   SourceLocation getLocation(CodePtr PC) const;
+  SourceRange getRange(CodePtr PC) const;
 
   unsigned getDepth() const { return Depth; }
 
 private:
   /// Returns an original argument from the stack.
   template <typename T> const T &stackRef(unsigned Offset) const {
     assert(Args);
     return *reinterpret_cast<const T *>(Args - ArgSize + Offset);

clang/lib/AST/Interp/InterpFrame.cpp

 const Expr *InterpFrame::getExpr(CodePtr PC) const {
   return S.getExpr(Func, PC);
 }
 
 SourceLocation InterpFrame::getLocation(CodePtr PC) const {
   return S.getLocation(Func, PC);
 }
 
+SourceRange InterpFrame::getRange(CodePtr PC) const {
+  return S.getRange(Func, PC);
+}

clang/lib/AST/Interp/Source.h

 /// Describes the statement/declaration an opcode was generated from.
 class SourceInfo final {
 public:
   SourceInfo() {}
   SourceInfo(const Stmt *E) : Source(E) {}
   SourceInfo(const Decl *D) : Source(D) {}
 
   SourceLocation getLoc() const;
+  SourceRange getRange() const;
 
   const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }
   const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
   const Expr *asExpr() const;
 
   operator bool() const { return !Source.isNull(); }
 
 private:
public:
 
   /// Returns source information for a given PC in a function.
   virtual SourceInfo getSource(const Function *F, CodePtr PC) const = 0;
 
   /// Returns the expression if an opcode belongs to one, null otherwise.
   const Expr *getExpr(const Function *F, CodePtr PC) const;
   /// Returns the location from which an opcode originates.
   SourceLocation getLocation(const Function *F, CodePtr PC) const;
+  SourceRange getRange(const Function *F, CodePtr PC) const;
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Source.cpp

if (const Expr *E = asExpr())
     return E->getExprLoc();
   if (const Stmt *S = asStmt())
     return S->getBeginLoc();
   if (const Decl *D = asDecl())
     return D->getBeginLoc();
   return SourceLocation();
 }
 
+SourceRange SourceInfo::getRange() const {
+  if (const Expr *E = asExpr())
+    return E->getSourceRange();
+  if (const Stmt *S = asStmt())
+    return S->getSourceRange();
+  if (const Decl *D = asDecl())
+    return D->getSourceRange();
+  return SourceRange();
+}
+
 const Expr *SourceInfo::asExpr() const {
   if (auto *S = Source.dyn_cast<const Stmt *>())
     return dyn_cast<Expr>(S);
   return nullptr;
 }
 
 const Expr *SourceMapper::getExpr(const Function *F, CodePtr PC) const {
   if (const Expr *E = getSource(F, PC).asExpr())
     return E;
   llvm::report_fatal_error("missing source expression");
 }
 
 SourceLocation SourceMapper::getLocation(const Function *F, CodePtr PC) const {
   return getSource(F, PC).getLoc();
 }
+
+SourceRange SourceMapper::getRange(const Function *F, CodePtr PC) const {
+  return getSource(F, PC).getRange();
+}

clang/test/Misc/constexpr-source-ranges.cpp

+// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-print-source-range-info -fcxx-exceptions %s 2>&1 | FileCheck %s
+// RUN: not %clang_cc1 -fsyntax-only -fexperimental-new-constant-interpreter -fdiagnostics-print-source-range-info -fcxx-exceptions %s 2>&1 | FileCheck %s
+
+constexpr int f() {
+  throw 1;
+  return 0;
+}
+
+// CHECK: constexpr-source-ranges.cpp:5:3:{5:3-5:10}