From 2b7334cf0ca4ef1c7af14ac4895271fef4ab7c7b Mon Sep 17 00:00:00 2001 From: Vaibhav Thakkar Date: Thu, 11 Apr 2024 01:10:44 +0200 Subject: [PATCH] Fix failures in debug mode --- .github/workflows/ci.yml | 2 +- include/clad/Differentiator/CladUtils.h | 3 +- include/clad/Differentiator/VisitorBase.h | 12 ++-- lib/Differentiator/BaseForwardModeVisitor.cpp | 45 +++++++------- lib/Differentiator/CladUtils.cpp | 6 +- .../ReverseModeForwPassVisitor.cpp | 9 ++- lib/Differentiator/ReverseModeVisitor.cpp | 57 +++++++++--------- lib/Differentiator/VisitorBase.cpp | 59 +++++++++---------- test/Gradient/MemberFunctions.C | 2 - 9 files changed, 100 insertions(+), 95 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 87d087b7a..dc8e54938 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -911,7 +911,7 @@ jobs: cat obj/CMakeCache.txt cat obj/CMakeFiles/*.log - name: Setup tmate session - if: ${{ failure() && runner.debug }} + if: ${{ failure() && matrix.debug_build == true }} uses: mxschmitt/action-tmate@v3 # When debugging increase to a suitable value! timeout-minutes: 30 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 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 argExprs, - bool useRefQualifiedThisObj = false); + clang::Expr* BuildCallExprToMemFn( + clang::CXXMethodDecl* FD, llvm::MutableArrayRef 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 SaveContext(m_Sema.CurContext); llvm::SaveAndRestore SaveScope(getCurrentScope()); DeclContext* DC = const_cast(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(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 paramTypes; llvm::SmallVector 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 CallArgs{}; llvm::SmallVector 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(CallArgs), noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), + validLoc, llvm::MutableArrayRef(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(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(CallArgs), noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), validLoc, + llvm::MutableArrayRef(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(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 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(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 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(CallArgs), noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc, + llvm::MutableArrayRef(CallArgs), Loc) .get(); Expr* call_dx = m_Sema - .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc, - llvm::MutableArrayRef(DerivedCallArgs), - noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc, + llvm::MutableArrayRef(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(CallArgs), noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc, + llvm::MutableArrayRef(CallArgs), Loc) .get(); Expr* call_dx = m_Sema - .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), noLoc, - llvm::MutableArrayRef(DerivedCallArgs), - noLoc) + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc, + llvm::MutableArrayRef(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(CallArgs), - noLoc) - .get(); + Expr* call = + m_Sema + .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()), Loc, + llvm::MutableArrayRef(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(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 ArgExprs, ValueDecl* memberDecl) { + MutableArrayRef 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(); - // 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 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"