Move the checks of call arguments for being temporary exprs to a routine

include/clad/Differentiator/CladUtils.h

@@ -174,11 +174,12 @@ namespace clad {
     /// otherwise returns false.
     bool HasAnyReferenceOrPointerArgument(const clang::FunctionDecl* FD);
 
-    /// Returns true if `T` is a reference, pointer or array type.
+    /// Returns true if `arg` is an argument passed by reference or is of
+    /// pointer/array type.
     ///
-    /// \note Please note that this function returns true for array types as
-    /// well.
-    bool IsReferenceOrPointerType(clang::QualType T);
+    /// \note Please note that this function returns false for temporary
+    /// expressions.
+    bool IsReferenceOrPointerArg(const clang::Expr* arg);
 
     /// Returns true if `T1` and `T2` have same cononical type; otherwise
     /// returns false.

lib/Differentiator/CladUtils.cpp

@@ -301,8 +301,12 @@ namespace clad {
       return false;
     }
 
-    bool IsReferenceOrPointerType(QualType T) {
-      return T->isReferenceType() || isArrayOrPointerType(T);
+    bool IsReferenceOrPointerArg(const Expr* arg) {
+      // The argument is passed by reference if it's passed as an L-value.
+      // However, if arg is a MaterializeTemporaryExpr, then arg is a
+      // temporary variable passed as a const reference.
+      bool isRefType = arg->isLValue() && !isa<MaterializeTemporaryExpr>(arg);
+      return isRefType || isArrayOrPointerType(arg->getType());
     }
 
     bool SameCanonicalType(clang::QualType T1, clang::QualType T2) {

lib/Differentiator/ReverseModeVisitor.cpp

@@ -1537,8 +1537,7 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       // We do not need to create result arg for arguments passed by reference
       // because the derivatives of arguments passed by reference are directly
       // modified by the derived callee function.
-      if (utils::IsReferenceOrPointerType(PVD->getType()) &&
-          !isa<MaterializeTemporaryExpr>(arg)) {
+      if (utils::IsReferenceOrPointerArg(arg)) {
         argDiff = Visit(arg);
         CallArgDx.push_back(argDiff.getExpr_dx());
       } else {
@@ -1723,9 +1722,7 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       for (auto* argDerivative : CallArgDx) {
         Expr* gradArgExpr = nullptr;
         const Expr* arg = CE->getArg(idx);
-        const auto* PVD = FD->getParamDecl(idx);
-        if (utils::IsReferenceOrPointerType(PVD->getType()) &&
-            !isa<MaterializeTemporaryExpr>(arg)) {
+        if (utils::IsReferenceOrPointerArg(arg)) {
           if (argDerivative) {
             if (utils::isArrayOrPointerType(argDerivative->getType()) ||
                 isCladArrayType(argDerivative->getType()) ||