Support [[clad::non_differentiable]] in reverse mode

fixes #717

lib/Differentiator/ReverseModeVisitor.cpp

@@ -1387,6 +1387,26 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
       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
+      llvm::SmallVector<Expr*, 4> ClonedArgs;
+      for (unsigned i = 0, e = CE->getNumArgs(); i < e; ++i)
+        ClonedArgs.push_back(Clone(CE->getArg(i)));
+
+      Expr* Call = m_Sema
+                       .ActOnCallExpr(getCurrentScope(), Clone(CE->getCallee()),
+                                      validLoc, ClonedArgs, validLoc)
+                       .get();
+      // Creating a zero derivative
+      auto* zero =
+          ConstantFolder::synthesizeLiteral(m_Context.IntTy, m_Context, 0);
+
+      // Returning the function call and zero derivative
+      return StmtDiff(Call, zero);
+    }
+
     auto NArgs = FD->getNumParams();
     // If the function has no args and is not a member function call then we
     // assume that it is not related to independent variables and does not
@@ -2790,6 +2810,32 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
     llvm::SmallVector<Decl*, 4> declsDiff;
     // Need to put array decls inlined.
     llvm::SmallVector<Decl*, 4> localDeclsDiff;
+
+    // If the type is marked as non_differentiable, skip generating its
+    // derivative Get the iterator
+    const auto* declsBegin = DS->decls().begin();
+    const auto* declsEnd = DS->decls().end();
+
+    // If the DeclStmt is not empty, check the first declaration.
+    if (declsBegin != declsEnd && isa<VarDecl>(*declsBegin)) {
+      auto* VD = dyn_cast<VarDecl>(*declsBegin);
+      // Check for non-differentiable types.
+      QualType QT = VD->getType();
+      if (QT->isPointerType())
+        QT = QT->getPointeeType();
+      auto* typeDecl = QT->getAsCXXRecordDecl();
+      if (typeDecl && clad::utils::hasNonDifferentiableAttribute(typeDecl)) {
+        for (auto* D : DS->decls())
+          if (auto* VD = dyn_cast<VarDecl>(D))
+            decls.push_back(VD);
+          else
+            diag(DiagnosticsEngine::Warning, D->getEndLoc(),
+                 "Unsupported declaration");
+        Stmt* DSClone = BuildDeclStmt(decls);
+        return StmtDiff(DSClone, nullptr);
+      }
+    }
+
     // reverse_mode_forward_pass does not have a reverse pass so declarations
     // don't have to be moved to the function global scope.
     bool promoteToFnScope = !getCurrentScope()->isFunctionScope() &&
@@ -2972,6 +3018,10 @@ Expr* getArraySizeExpr(const ArrayType* AT, ASTContext& context,
            "CXXMethodDecl nodes not supported yet!");
     MemberExpr* clonedME = utils::BuildMemberExpr(
         m_Sema, getCurrentScope(), baseDiff.getExpr(), field->getName());
+    auto zero =
+        ConstantFolder::synthesizeLiteral(m_Context.DoubleTy, m_Context, 0);
+    if (clad::utils::hasNonDifferentiableAttribute(ME))
+      return {clonedME, zero};
     if (!baseDiff.getExpr_dx())
       return {clonedME, nullptr};
     MemberExpr* derivedME = utils::BuildMemberExpr(