diff --git a/include/clad/Differentiator/CladUtils.h b/include/clad/Differentiator/CladUtils.h
index ffc90be12..ae2d26a99 100644
--- a/include/clad/Differentiator/CladUtils.h
+++ b/include/clad/Differentiator/CladUtils.h
@@ -216,7 +216,8 @@ namespace clad {
                      clang::IdentifierInfo* II, clang::QualType T,
                      clang::StorageClass SC = clang::StorageClass::SC_None,
                      clang::Expr* defArg = nullptr,
-                     clang::TypeSourceInfo* TSI = nullptr);
+                     clang::TypeSourceInfo* TSI = nullptr,
+                     clang::SourceLocation Loc = clang::SourceLocation());
 
     /// If `T` represents an array or a pointer type then returns the
     /// corresponding array element or the pointee type. If `T` is a reference
diff --git a/include/clad/Differentiator/VisitorBase.h b/include/clad/Differentiator/VisitorBase.h
index 0bbc13290..60aaa356f 100644
--- a/include/clad/Differentiator/VisitorBase.h
+++ b/include/clad/Differentiator/VisitorBase.h
@@ -500,7 +500,7 @@ namespace clad {
     clang::Expr*
     BuildCallExprToMemFn(clang::Expr* Base, llvm::StringRef MemberFunctionName,
                          llvm::MutableArrayRef<clang::Expr*> ArgExprs,
-                         clang::ValueDecl* memberDecl = nullptr);
+                         clang::SourceLocation Loc = noLoc);
 
     /// Build a call to member function through this pointer.
     ///
@@ -509,10 +509,9 @@ namespace clad {
     /// \param[in] useRefQualifiedThisObj If true, then the `this` object is
     /// perfectly forwarded while calling member functions.
     /// \returns Built member function call expression
-    clang::Expr*
-    BuildCallExprToMemFn(clang::CXXMethodDecl* FD,
-                         llvm::MutableArrayRef<clang::Expr*> argExprs,
-                         bool useRefQualifiedThisObj = false);
+    clang::Expr* BuildCallExprToMemFn(
+        clang::CXXMethodDecl* FD, llvm::MutableArrayRef<clang::Expr*> argExprs,
+        bool useRefQualifiedThisObj = false, clang::SourceLocation Loc = noLoc);
 
     /// Build a call to a free function or member function through
     /// this pointer depending on whether the `FD` argument corresponds to a
@@ -577,7 +576,8 @@ namespace clad {
     clang::ParmVarDecl* CloneParmVarDecl(const clang::ParmVarDecl* PVD,
                                          clang::IdentifierInfo* II,
                                          bool pushOnScopeChains = false,
-                                         bool cloneDefaultArg = true);
+                                         bool cloneDefaultArg = true,
+                                         clang::SourceLocation Loc = noLoc);
     /// A function to get the single argument "forward_central_difference"
     /// call expression for the given arguments.
     ///
diff --git a/lib/Differentiator/BaseForwardModeVisitor.cpp b/lib/Differentiator/BaseForwardModeVisitor.cpp
index 13ba31176..9ce8d9a2e 100644
--- a/lib/Differentiator/BaseForwardModeVisitor.cpp
+++ b/lib/Differentiator/BaseForwardModeVisitor.cpp
@@ -162,14 +162,14 @@ BaseForwardModeVisitor::Derive(const FunctionDecl* FD,
 
   IdentifierInfo* II = &m_Context.Idents.get(
       request.BaseFunctionName + "_d" + s + "arg" + argInfo + derivativeSuffix);
-  SourceLocation loc{m_Function->getLocation()};
-  DeclarationNameInfo name(II, loc);
+  SourceLocation validLoc{m_Function->getLocation()};
+  DeclarationNameInfo name(II, validLoc);
   llvm::SaveAndRestore<DeclContext*> SaveContext(m_Sema.CurContext);
   llvm::SaveAndRestore<Scope*> SaveScope(getCurrentScope());
   DeclContext* DC = const_cast<DeclContext*>(m_Function->getDeclContext());
   m_Sema.CurContext = DC;
   DeclWithContext result =
-      m_Builder.cloneFunction(FD, *this, DC, loc, name, FD->getType());
+      m_Builder.cloneFunction(FD, *this, DC, validLoc, name, FD->getType());
   FunctionDecl* derivedFD = result.first;
   m_Derivative = derivedFD;
 
@@ -190,8 +190,8 @@ BaseForwardModeVisitor::Derive(const FunctionDecl* FD,
     if (PVD->hasDefaultArg())
       clonedPVDDefaultArg = Clone(PVD->getDefaultArg());
 
-    newPVD = ParmVarDecl::Create(m_Context, m_Sema.CurContext, noLoc, noLoc,
-                                 PVD->getIdentifier(), PVD->getType(),
+    newPVD = ParmVarDecl::Create(m_Context, m_Sema.CurContext, validLoc,
+                                 validLoc, PVD->getIdentifier(), PVD->getType(),
                                  PVD->getTypeSourceInfo(),
                                  PVD->getStorageClass(), clonedPVDDefaultArg);
 
@@ -322,13 +322,14 @@ BaseForwardModeVisitor::Derive(const FunctionDecl* FD,
                 m_Context.IntTy, m_Context, dValue);
             dArrVal.push_back(dValueLiteral);
           }
-          dInitializer = m_Sema.ActOnInitList(noLoc, dArrVal, noLoc).get();
+          dInitializer =
+              m_Sema.ActOnInitList(validLoc, dArrVal, validLoc).get();
         } else if (const auto* ptrType =
                        dyn_cast<PointerType>(fieldType.getTypePtr())) {
           if (!ptrType->getPointeeType()->isRealType())
             continue;
           // Pointer member variables should be initialised by `nullptr`.
-          dInitializer = m_Sema.ActOnCXXNullPtrLiteral(noLoc).get();
+          dInitializer = m_Sema.ActOnCXXNullPtrLiteral(validLoc).get();
         } else {
           int dValue = (fieldDecl == m_IndependentVar);
           dInitializer = ConstantFolder::synthesizeLiteral(m_Context.IntTy,
@@ -403,7 +404,7 @@ BaseForwardModeVisitor::DerivePushforward(const FunctionDecl* FD,
 
   IdentifierInfo* derivedFnII = &m_Context.Idents.get(
       originalFnEffectiveName + GetPushForwardFunctionSuffix());
-  DeclarationNameInfo derivedFnName(derivedFnII, noLoc);
+  DeclarationNameInfo derivedFnName(derivedFnII, m_Function->getLocation());
   llvm::SmallVector<QualType, 16> paramTypes;
   llvm::SmallVector<QualType, 16> derivedParamTypes;
 
@@ -984,6 +985,8 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
     return StmtDiff(Clone(CE));
   }
 
+  SourceLocation validLoc{CE->getBeginLoc()};
+
   // If the function is non_differentiable, return zero derivative.
   if (clad::utils::hasNonDifferentiableAttribute(CE)) {
     // Calling the function without computing derivatives
@@ -993,7 +996,7 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
 
     Expr* Call = m_Sema
                      .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()),
-                                    noLoc, ClonedArgs, noLoc)
+                                    validLoc, ClonedArgs, validLoc)
                      .get();
     // Creating a zero derivative
     auto* zero =
@@ -1008,7 +1011,6 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
   if (m_DerivativeOrder == 1)
     s = "";
 
-  SourceLocation noLoc;
   llvm::SmallVector<Expr*, 4> CallArgs{};
   llvm::SmallVector<Expr*, 4> diffArgs;
 
@@ -1108,7 +1110,7 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
     callDiff =
         m_Sema
             .ActOnCallExpr(m_Sema.getScopeForContext(m_Sema.CurContext),
-                           derivativeRef, noLoc, pushforwardFnArgs, noLoc)
+                           derivativeRef, validLoc, pushforwardFnArgs, validLoc)
             .get();
   }
 
@@ -1132,8 +1134,9 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
       if (allArgsAreConstantLiterals) {
         Expr* call =
             m_Sema
-                .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                               llvm::MutableArrayRef<Expr*>(CallArgs), noLoc)
+                .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()),
+                               validLoc, llvm::MutableArrayRef<Expr*>(CallArgs),
+                               validLoc)
                 .get();
         auto* zero =
             ConstantFolder::synthesizeLiteral(m_Context.IntTy, m_Context, 0);
@@ -1168,16 +1171,16 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
       if (baseDiff.getExpr()) {
         callDiff =
             BuildCallExprToMemFn(baseDiff.getExpr(), pushforwardFD->getName(),
-                                 pushforwardFnArgs, pushforwardFD);
+                                 pushforwardFnArgs, CE->getBeginLoc());
       } else {
         Expr* execConfig = nullptr;
         if (auto KCE = dyn_cast<CUDAKernelCallExpr>(CE))
           execConfig = Clone(KCE->getConfig());
-        callDiff =
-            m_Sema
-                .ActOnCallExpr(getCurrentScope(), BuildDeclRef(pushforwardFD),
-                               noLoc, pushforwardFnArgs, noLoc, execConfig)
-                .get();
+        callDiff = m_Sema
+                       .ActOnCallExpr(getCurrentScope(),
+                                      BuildDeclRef(pushforwardFD), validLoc,
+                                      pushforwardFnArgs, validLoc, execConfig)
+                       .get();
       }
     }
   }
@@ -1188,8 +1191,8 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
     Multiplier = diffArgs[0];
     Expr* call =
         m_Sema
-            .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                           llvm::MutableArrayRef<Expr*>(CallArgs), noLoc)
+            .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), validLoc,
+                           llvm::MutableArrayRef<Expr*>(CallArgs), validLoc)
             .get();
     // FIXME: Extend this for multiarg support
     // Check if the function is eligible for numerical differentiation.
diff --git a/lib/Differentiator/CladUtils.cpp b/lib/Differentiator/CladUtils.cpp
index adaf5d29b..c180d0b1a 100644
--- a/lib/Differentiator/CladUtils.cpp
+++ b/lib/Differentiator/CladUtils.cpp
@@ -346,12 +346,14 @@ namespace clad {
     BuildParmVarDecl(clang::Sema& semaRef, clang::DeclContext* DC,
                      clang::IdentifierInfo* II, clang::QualType T,
                      clang::StorageClass SC, clang::Expr* defArg,
-                     clang::TypeSourceInfo* TSI) {
+                     clang::TypeSourceInfo* TSI, clang::SourceLocation Loc) {
       ASTContext& C = semaRef.getASTContext();
       if (!TSI)
         TSI = C.getTrivialTypeSourceInfo(T, noLoc);
+      if (Loc.isInvalid())
+        Loc = utils::GetValidSLoc(semaRef);
       ParmVarDecl* PVD =
-          ParmVarDecl::Create(C, DC, noLoc, noLoc, II, T, TSI, SC, defArg);
+          ParmVarDecl::Create(C, DC, Loc, Loc, II, T, TSI, SC, defArg);
       return PVD;
     }
 
diff --git a/lib/Differentiator/ReverseModeForwPassVisitor.cpp b/lib/Differentiator/ReverseModeForwPassVisitor.cpp
index 1d51bb314..7c444415f 100644
--- a/lib/Differentiator/ReverseModeForwPassVisitor.cpp
+++ b/lib/Differentiator/ReverseModeForwPassVisitor.cpp
@@ -44,8 +44,9 @@ ReverseModeForwPassVisitor::Derive(const FunctionDecl* FD,
   // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
   m_Sema.CurContext = const_cast<DeclContext*>(m_Function->getDeclContext());
 
+  SourceLocation validLoc{m_Function->getLocation()};
   DeclWithContext fnBuildRes = m_Builder.cloneFunction(
-      m_Function, *this, m_Sema.CurContext, noLoc, fnDNI, fnType);
+      m_Function, *this, m_Sema.CurContext, validLoc, fnDNI, fnType);
   m_Derivative = fnBuildRes.first;
 
   beginScope(Scope::FunctionPrototypeScope | Scope::FunctionDeclarationScope |
@@ -240,8 +241,10 @@ ReverseModeForwPassVisitor::VisitReturnStmt(const clang::ReturnStmt* RS) {
   auto returnDiff = Visit(value);
   llvm::SmallVector<Expr*, 2> returnArgs = {returnDiff.getExpr(),
                                             returnDiff.getExpr_dx()};
-  Expr* returnInitList = m_Sema.ActOnInitList(noLoc, returnArgs, noLoc).get();
-  Stmt* newRS = m_Sema.BuildReturnStmt(noLoc, returnInitList).get();
+  SourceLocation validLoc{RS->getBeginLoc()};
+  Expr* returnInitList =
+      m_Sema.ActOnInitList(validLoc, returnArgs, validLoc).get();
+  Stmt* newRS = m_Sema.BuildReturnStmt(validLoc, returnInitList).get();
   return {newRS};
 }
 
diff --git a/lib/Differentiator/ReverseModeVisitor.cpp b/lib/Differentiator/ReverseModeVisitor.cpp
index b461604a0..db2255cdf 100644
--- a/lib/Differentiator/ReverseModeVisitor.cpp
+++ b/lib/Differentiator/ReverseModeVisitor.cpp
@@ -513,8 +513,9 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
                                            getEnclosingNamespaceOrTUScope());
     m_Sema.CurContext = const_cast<DeclContext*>(m_Function->getDeclContext());
 
+    SourceLocation validLoc{m_Function->getLocation()};
     DeclWithContext fnBuildRes = m_Builder.cloneFunction(
-        m_Function, *this, m_Sema.CurContext, noLoc, DNI, pullbackFnType);
+        m_Function, *this, m_Sema.CurContext, validLoc, DNI, pullbackFnType);
     m_Derivative = fnBuildRes.first;
 
     if (m_ExternalSource)
@@ -1436,6 +1437,8 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
         return StmtDiff(Clone(CE), Clone(CE));
     }
 
+    SourceLocation Loc = CE->getExprLoc();
+
     // Stores the call arguments for the function to be derived
     llvm::SmallVector<Expr*, 16> CallArgs{};
     // Stores the dx of the call arguments for the function to be derived
@@ -1460,14 +1463,13 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       }
       Expr* call =
           m_Sema
-              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                             llvm::MutableArrayRef<Expr*>(CallArgs), noLoc)
+              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                             llvm::MutableArrayRef<Expr*>(CallArgs), Loc)
               .get();
       Expr* call_dx =
           m_Sema
-              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                             llvm::MutableArrayRef<Expr*>(DerivedCallArgs),
-                             noLoc)
+              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                             llvm::MutableArrayRef<Expr*>(DerivedCallArgs), Loc)
               .get();
       return StmtDiff(call, call_dx);
     }
@@ -1483,14 +1485,13 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       }
       Expr* call =
           m_Sema
-              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                             llvm::MutableArrayRef<Expr*>(CallArgs), noLoc)
+              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                             llvm::MutableArrayRef<Expr*>(CallArgs), Loc)
               .get();
       Expr* call_dx =
           m_Sema
-              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                             llvm::MutableArrayRef<Expr*>(DerivedCallArgs),
-                             noLoc)
+              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                             llvm::MutableArrayRef<Expr*>(DerivedCallArgs), Loc)
               .get();
       m_DeallocExprs.push_back(call);
       m_DeallocExprs.push_back(call_dx);
@@ -1510,13 +1511,11 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
         StmtDiff ArgDiff = Visit(Arg, dfdx());
         CallArgs.push_back(ArgDiff.getExpr());
       }
-      Expr* call = m_Sema
-                       .ActOnCallExpr(getCurrentScope(),
-                                      Clone(CE->getCallee()),
-                                      noLoc,
-                                      llvm::MutableArrayRef<Expr*>(CallArgs),
-                                      noLoc)
-                       .get();
+      Expr* call =
+          m_Sema
+              .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                             llvm::MutableArrayRef<Expr*>(CallArgs), Loc)
+              .get();
       return call;
     }
 
@@ -1779,7 +1778,7 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
 
         OverloadedDerivedFn = m_Sema
                                   .ActOnCallExpr(getCurrentScope(), selfRef,
-                                                 noLoc, pullbackCallArgs, noLoc)
+                                                 Loc, pullbackCallArgs, Loc)
                                   .get();
       } else {
         if (m_ExternalSource)
@@ -1852,12 +1851,12 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
           if (baseDiff.getExpr()) {
             Expr* baseE = baseDiff.getExpr();
             OverloadedDerivedFn = BuildCallExprToMemFn(
-                baseE, pullbackFD->getName(), pullbackCallArgs, pullbackFD);
+                baseE, pullbackFD->getName(), pullbackCallArgs, Loc);
           } else {
             OverloadedDerivedFn =
                 m_Sema
                     .ActOnCallExpr(getCurrentScope(), BuildDeclRef(pullbackFD),
-                                   noLoc, pullbackCallArgs, noLoc)
+                                   Loc, pullbackCallArgs, Loc)
                     .get();
           }
         }
@@ -1939,7 +1938,7 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
         // else
         // Currently derivedBase `*d_this` can never be CladArrayType
         CallArgs.push_back(
-            BuildOp(UnaryOperatorKind::UO_AddrOf, derivedBase, noLoc));
+            BuildOp(UnaryOperatorKind::UO_AddrOf, derivedBase, Loc));
       }
 
       for (std::size_t i = static_cast<std::size_t>(isCXXOperatorCall),
@@ -1958,19 +1957,19 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
           //   CallArgs.push_back(derivedArg);
           // else
           CallArgs.push_back(
-              BuildOp(UnaryOperatorKind::UO_AddrOf, derivedArg, noLoc));
+              BuildOp(UnaryOperatorKind::UO_AddrOf, derivedArg, Loc));
         } else
-          CallArgs.push_back(m_Sema.ActOnCXXNullPtrLiteral(noLoc).get());
+          CallArgs.push_back(m_Sema.ActOnCXXNullPtrLiteral(Loc).get());
       }
       if (baseDiff.getExpr()) {
         Expr* baseE = baseDiff.getExpr();
         call = BuildCallExprToMemFn(baseE, calleeFnForwPassFD->getName(),
-                                    CallArgs, calleeFnForwPassFD);
+                                    CallArgs, Loc);
       } else {
         call = m_Sema
                    .ActOnCallExpr(getCurrentScope(),
-                                  BuildDeclRef(calleeFnForwPassFD), noLoc,
-                                  CallArgs, noLoc)
+                                  BuildDeclRef(calleeFnForwPassFD), Loc,
+                                  CallArgs, Loc)
                    .get();
       }
       auto* callRes = StoreAndRef(call);
@@ -1981,8 +1980,8 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       return StmtDiff(resValue, nullptr, resAdjoint);
     } // Recreate the original call expression.
     call = m_Sema
-               .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc,
-                              CallArgs, noLoc)
+               .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc,
+                              CallArgs, Loc)
                .get();
     return StmtDiff(call);
 
diff --git a/lib/Differentiator/VisitorBase.cpp b/lib/Differentiator/VisitorBase.cpp
index a482c29ab..df3e5cb9d 100644
--- a/lib/Differentiator/VisitorBase.cpp
+++ b/lib/Differentiator/VisitorBase.cpp
@@ -34,7 +34,11 @@ using namespace clang;
 namespace clad {
   clang::CompoundStmt* VisitorBase::MakeCompoundStmt(const Stmts& Stmts) {
     auto Stmts_ref = clad_compat::makeArrayRef(Stmts.data(), Stmts.size());
-    return clad_compat::CompoundStmt_Create(m_Context, Stmts_ref /**/ CLAD_COMPAT_CLANG15_CompoundStmt_Create_ExtraParam2(FPOptionsOverride()), noLoc, noLoc);
+    return clad_compat::CompoundStmt_Create(
+        m_Context,
+        Stmts_ref /**/ CLAD_COMPAT_CLANG15_CompoundStmt_Create_ExtraParam2(
+            FPOptionsOverride()),
+        utils::GetValidSLoc(m_Sema), utils::GetValidSLoc(m_Sema));
   }
 
   bool VisitorBase::isUnusedResult(const Expr* E) {
@@ -524,32 +528,22 @@ namespace clad {
 
   Expr* VisitorBase::BuildCallExprToMemFn(Expr* Base,
                                           StringRef MemberFunctionName,
-                                          MutableArrayRef<Expr*> ArgExprs, ValueDecl* memberDecl) {
+                                          MutableArrayRef<Expr*> ArgExprs,
+                                          SourceLocation Loc /*=noLoc*/) {
+    if (Loc.isInvalid())
+      Loc = m_Function->getLocation();
     UnqualifiedId Member;
-    Member.setIdentifier(&m_Context.Idents.get(MemberFunctionName), noLoc);
+    Member.setIdentifier(&m_Context.Idents.get(MemberFunctionName), Loc);
     CXXScopeSpec SS;
     bool isArrow = Base->getType()->isPointerType();
     auto ME = m_Sema
-                  .ActOnMemberAccessExpr(getCurrentScope(), Base, noLoc,
+                  .ActOnMemberAccessExpr(getCurrentScope(), Base, Loc,
                                          isArrow ? tok::TokenKind::arrow
                                                  : tok::TokenKind::period,
                                          SS, noLoc, Member,
                                          /*ObjCImpDecl=*/nullptr)
                   .getAs<MemberExpr>();
-    // FIXME: This is a workaround and it's dependency should be removed soon.
-    // Currently, member function derivatives are not being registered properly.
-    // If there are member function derivatives overloads then only one of the
-    // overload is being found by Sema lookup.
-    // Ideally, if `MemberFunctionName` corresponds to an overloaded member
-    // function name, then `Sema::ActOnMemberAccessExpr` should return an
-    // unresolved expression and `Sema::ActOnCallExpr` should automatically
-    // resolve this unresolved expression on the basis of the call arguments
-    // provided. But currently, since only one of the member function overload
-    // is found by the lookup, unresolved expression is not created and thus, we
-    // explicitly should assign the correct member function whenever we can.
-    if (memberDecl)
-      ME->setMemberDecl(memberDecl);
-    return m_Sema.ActOnCallExpr(getCurrentScope(), ME, noLoc, ArgExprs, noLoc)
+    return m_Sema.ActOnCallExpr(getCurrentScope(), ME, Loc, ArgExprs, Loc)
         .get();
   }
 
@@ -568,9 +562,11 @@ namespace clad {
 
   Expr* VisitorBase::BuildCallExprToMemFn(
       clang::CXXMethodDecl* FD, llvm::MutableArrayRef<clang::Expr*> argExprs,
-      bool useRefQualifiedThisObj) {
+      bool useRefQualifiedThisObj, SourceLocation Loc /*=noLoc*/) {
     Expr* thisExpr = clad_compat::Sema_BuildCXXThisExpr(m_Sema, FD);
     bool isArrow = true;
+    if (Loc.isInvalid())
+      Loc = m_Function->getLocation();
 
     // C++ does not support perfect forwarding of `*this` object inside
     // a member function.
@@ -596,16 +592,16 @@ namespace clad {
     NestedNameSpecifierLoc NNS(FD->getQualifier(),
                                /*Data=*/nullptr);
     auto DAP = DeclAccessPair::make(FD, FD->getAccess());
-    auto memberExpr = MemberExpr::
-        Create(m_Context, thisExpr, isArrow, noLoc, NNS, noLoc, FD, DAP,
-               FD->getNameInfo(),
-               /*TemplateArgs=*/nullptr, m_Context.BoundMemberTy,
-               CLAD_COMPAT_ExprValueKind_R_or_PR_Value,
-               ExprObjectKind::OK_Ordinary
-                   CLAD_COMPAT_CLANG9_MemberExpr_ExtraParams(NOUR_None));
+    auto* memberExpr = MemberExpr::Create(
+        m_Context, thisExpr, isArrow, Loc, NNS, noLoc, FD, DAP,
+        FD->getNameInfo(),
+        /*TemplateArgs=*/nullptr, m_Context.BoundMemberTy,
+        CLAD_COMPAT_ExprValueKind_R_or_PR_Value,
+        ExprObjectKind::OK_Ordinary CLAD_COMPAT_CLANG9_MemberExpr_ExtraParams(
+            NOUR_None));
     return m_Sema
-        .BuildCallToMemberFunction(getCurrentScope(), memberExpr, noLoc,
-                                   argExprs, noLoc)
+        .BuildCallToMemberFunction(getCurrentScope(), memberExpr, Loc, argExprs,
+                                   Loc)
         .get();
   }
 
@@ -769,13 +765,16 @@ namespace clad {
   ParmVarDecl* VisitorBase::CloneParmVarDecl(const ParmVarDecl* PVD,
                                              IdentifierInfo* II,
                                              bool pushOnScopeChains,
-                                             bool cloneDefaultArg) {
+                                             bool cloneDefaultArg,
+                                             SourceLocation Loc) {
     Expr* newPVDDefaultArg = nullptr;
     if (PVD->hasDefaultArg() && cloneDefaultArg) {
       newPVDDefaultArg = Clone(PVD->getDefaultArg());
     }
+    if (Loc.isInvalid())
+      Loc = PVD->getLocation();
     auto newPVD = ParmVarDecl::Create(
-        m_Context, m_Sema.CurContext, noLoc, noLoc, II, PVD->getType(),
+        m_Context, m_Sema.CurContext, Loc, Loc, II, PVD->getType(),
         PVD->getTypeSourceInfo(), PVD->getStorageClass(), newPVDDefaultArg);
     if (pushOnScopeChains && newPVD->getIdentifier()) {
       m_Sema.PushOnScopeChains(newPVD, getCurrentScope(),
diff --git a/test/Gradient/MemberFunctions.C b/test/Gradient/MemberFunctions.C
index 26d5e2221..5956d80f7 100644
--- a/test/Gradient/MemberFunctions.C
+++ b/test/Gradient/MemberFunctions.C
@@ -13,8 +13,6 @@
 // RUN: %cladclang -Xclang -plugin-arg-clad -Xclang -enable-tbr -std=c++17 %s -fno-exceptions -I%S/../../include -oMemberFunctions-cpp17.out
 // RUN: ./MemberFunctions-cpp17.out | FileCheck -check-prefix=CHECK-EXEC %s
 
-// XFAIL: asserts
-
 //CHECK-NOT: {{.*error|warning|note:.*}}
 #include "clad/Differentiator/Differentiator.h"