Do not treat tensors in a special way

Copy-initialization of adjoints has proven to be more reliable than default initialization. However, when handling non-differentiable parameters (unlike other variables), we use this strategy only with tensor-like types. This PR generalizes this approach to all copiable record types.

Fixes #1526

Author: PetroZarytskyi

include/clad/Differentiator/CladUtils.h

@@ -417,10 +417,6 @@ namespace clad {
 
     bool IsDifferentiableType(clang::QualType T);
 
-    /// Returns true if T is a Tensor-like type. This type must be
-    /// forward-declared in the `clad::tensor_like` namespace.
-    bool isTensorLike(clang::Sema& SemaRef, clang::QualType T);
-
     bool hasElidableReverseForwAttribute(const clang::Decl* D);
 
     /// Returns true if FD can be differentiated as a pushforward

lib/Differentiator/CladUtils.cpp

@@ -1621,70 +1621,6 @@ namespace clad {
       return false;
     }
 
-    bool isTensorLike(clang::Sema& SemaRef, clang::QualType T) {
-      if (!isa<TemplateSpecializationType>(T) && !T->isRecordType())
-        return false;
-      // We check if the type is a vector, and if so, recursively check its
-      // template argument.
-      auto isVector = [](const TemplateSpecializationType* TST) {
-        TemplateName TM = TST->getTemplateName();
-        TemplateDecl* TD = TM.getAsTemplateDecl();
-        if (!TD)
-          return false;
-        return TD->getName() == "vector";
-      };
-
-      if (const auto* TST = T->getAs<TemplateSpecializationType>()) {
-        if (isVector(TST)) {
-          auto args = TST->template_arguments();
-          if (!args.empty()) {
-            // Recursively check the first template argument.
-            const clang::TemplateArgument& Arg = args[0];
-            if (Arg.getKind() == clang::TemplateArgument::Type)
-              return isTensorLike(SemaRef, Arg.getAsType());
-          }
-        }
-      }
-
-      const auto* CXXRD = T->getAsCXXRecordDecl();
-      // Find the special `tensor_like` namespace.
-      // This looks for `clad::tensor_like`.
-      clang::NamespaceDecl* CladNS =
-          utils::LookupNSD(SemaRef, "clad", /*shouldExist=*/true);
-      clang::NamespaceDecl* TensorLikeNS = utils::LookupNSD(
-          SemaRef, "tensor_like", /*shouldExist=*/false, CladNS);
-      if (!TensorLikeNS)
-        return false;
-
-      // Get the original type's name and its enclosing namespace.
-      clang::IdentifierInfo* TypeName = CXXRD->getIdentifier();
-      if (!TypeName)
-        return false;
-
-      const auto* OriginalDC = CXXRD->getDeclContext();
-      // The type is not in a namespace (e.g., it's a nested class or in
-      // global scope). You could extend this logic if needed, but for now,
-      // we'll assume tensor types are in a namespace like `at` or `cladtorch`.
-      if (!OriginalDC->isNamespace())
-        return false;
-      const auto* OriginalNS = clang::cast<clang::NamespaceDecl>(OriginalDC);
-      clang::IdentifierInfo* OriginalNSName = OriginalNS->getIdentifier();
-      if (!OriginalNSName)
-        return false;
-
-      clang::NamespaceDecl* FoundMirroredNS =
-          utils::LookupNSD(SemaRef, OriginalNSName->getName(),
-                           /*shouldExist=*/false, TensorLikeNS);
-      if (!FoundMirroredNS)
-        return false;
-
-      clang::LookupResult R(SemaRef, clang::DeclarationName(TypeName),
-                            clang::SourceLocation(),
-                            clang::Sema::LookupOrdinaryName);
-
-      return SemaRef.LookupQualifiedName(R, FoundMirroredNS) && !R.empty();
-    }
-
     /// Called in ShouldRecompute. In CUDA, to access a current thread/block id
     /// we use functions that do not change the state of any variable, since no
     /// point to store the value.

lib/Differentiator/ReverseModeVisitor.cpp

@@ -408,8 +408,20 @@ Expr* ReverseModeVisitor::getStdInitListSizeExpr(const Expr* E) {
         auto VDDerivedType = utils::getNonConstType(paramTy, m_Sema);
         VDDerivedType = VDDerivedType.getNonReferenceType();
         Expr* initExpr = nullptr;
+        // We initialize adjoints with original variables as part of
+        // the strategy to maintain the structure of the original variable.
+        // After that, we'll zero-initialize the adjoint. e.g.
+        // ```
+        // std::vector<...> v{x, y, z};
+        // std::vector<...> _d_v{v}; // The length of the vector is preserved
+        // clad::zero_init(_d_v);
+        // ```
+        // Also, if the original is initialized with a zero-constructor, it can
+        // be used for the adjoint as well.
+        const CXXRecordDecl* RD = VDDerivedType->getAsCXXRecordDecl();
+        bool isNonAggrClass = RD && !RD->isAggregate();
         bool isDirectInit = false;
-        if (clad::utils::isTensorLike(m_Sema, VDDerivedType)) {
+        if (isNonAggrClass && utils::isCopyable(RD)) {
           ParmVarDecl* newFuncParam = nullptr;
           for (auto* p : m_Derivative->parameters()) {
             if (p->getName() == param->getName()) {