[clang][Interp] Diagnose callsite for implicit functions

[tbaeder]

Summary

We don't have any code to point at here, so the diagnostics would just
point to the record declaration. Make them point to the call site
intead.

[cor3ntin]

LGTM!

clang/lib/AST/Interp/InterpFrame.cpp

Pointer InterpFrame::getParamPointer(unsigned Off) {
   TYPE_SWITCH(Desc.first, new (B->data()) T(stackRef<T>(Off)));
 
   // Record the param.
   Params.insert({Off, std::move(Memory)});
   return Pointer(B);
 }
 
 SourceInfo InterpFrame::getSource(CodePtr PC) const {
+  // Implicitly created functions don't have any code we could point at,
+  // so return the call site.
+  if (Func && Func->getDecl()->isImplicit() && Caller)
+    return Caller->getSource(RetPC);
+
   return S.getSource(Func, PC);
 }
 
 const Expr *InterpFrame::getExpr(CodePtr PC) const {
   return S.getExpr(Func, PC);
 }
 
 SourceLocation InterpFrame::getLocation(CodePtr PC) const {
   return S.getLocation(Func, PC);
 }
 

clang/test/AST/Interp/cxx20.cpp

namespace BaseAndFieldInit {
 
   struct C : B {
     int c;
   };
 
   constexpr C c = {1,2,3};
   static_assert(c.a == 1 && c.b == 2 && c.c == 3);
 }
+
+namespace ImplicitFunction {
+  struct A {
+    int a; // ref-note {{subobject declared here}}
+  };
+
+  constexpr int callMe() {
+   A a;
+   A b{12};
+
+   /// The operator= call here will fail and the diagnostics should be fine.
+   b = a; // ref-note {{subobject 'a' is not initialized}} \
+          // ref-note {{in call to}} \
+          // expected-note {{read of uninitialized object}} \
+          // expected-note {{in call to}}
+
+   return 1;
+  }
+  static_assert(callMe() == 1, ""); // ref-error {{not an integral constant expression}} \
+                                    // ref-note {{in call to 'callMe()'}} \
+                                    // expected-error {{not an integral constant expression}} \
+                                    // expected-note {{in call to 'callMe()'}}
+}