Disable setter generation for field of types with a deleted or private assigment operator

Author: grasph

src/CodeTree.cpp

@@ -78,8 +78,41 @@ namespace codetree{
     //Replace all '::' occurences by '!':
     return std::regex_replace(cpp_name, std::regex("::"), "!");
   }
+
+  bool isAssignable(CXCursor type_def){
+    if(verbose > 3) std::cerr << __FUNCTION__ << "(" << type_def << ")\n";
+
+    struct data_t {
+      bool copy_assignment_deleted;
+      bool copy_assignment_defined;
+      bool move_assignment_deleted;
+    } data = {false, false, false};
+    
+    clang_visitChildren(type_def, [](CXCursor cursor, CXCursor, CXClientData data_){
+      auto& data = *static_cast<data_t*>(data_);
+      const auto& access = clang_getCXXAccessSpecifier(cursor);
+      if(clang_CXXMethod_isCopyAssignmentOperator(cursor)){
+        if(clang_CXXMethod_isDeleted(cursor) || access != CX_CXXPublic){
+          data.copy_assignment_deleted = true;
+        } else{
+          data.copy_assignment_defined = true;
+        }
+      }
+
+      if(clang_CXXMethod_isMoveAssignmentOperator(cursor)
+         && (clang_CXXMethod_isDeleted(cursor) || access != CX_CXXPublic)){
+        data.move_assignment_deleted = true;
+      }
+      return CXChildVisit_Continue;
+    }, &data);
+  
+    bool not_assignable = data.copy_assignment_deleted
+      || (data.move_assignment_deleted && !data.copy_assignment_defined) ;
+    return !not_assignable;
+  }
 }
 
+
 CXCursor
 CodeTree::getParentClassForWrapper(CXCursor cursor) const{
   if(verbose > 5) std::cerr << "Calling getParentClassForWrapper("
@@ -474,11 +507,13 @@ CodeTree::generate_cxx_for_type(std::ostream& o,
           if(accessor_gen != accessor_mode_t::none){
             //skip field with anomymous struct types:
             bool anonymous = false;
+            bool assignable = true;
             CXType field_type = clang_getCursorType(f);
             if(field_type.kind != CXType_Invalid){
               auto def = clang_getTypeDeclaration(field_type);
-              if(!clang_Cursor_isNull(def) && clang_Cursor_isAnonymous(def)){
-                anonymous = true;
+              if(!clang_Cursor_isNull(def)){
+                anonymous = clang_Cursor_isAnonymous(def);
+                assignable = isAssignable(def);
               }
             }
             if(anonymous){
@@ -487,7 +522,8 @@ CodeTree::generate_cxx_for_type(std::ostream& o,
                           << " because its type is anonymous.\n";
               }
             } else{
-              generate_accessor_cxx(o, &t, f, accessor_gen == accessor_mode_t::getter, 2);
+              bool getter_only = (accessor_gen == accessor_mode_t::getter || !assignable);
+              generate_accessor_cxx(o, &t, f, getter_only, 2);
             }
           }
         }
@@ -925,9 +961,10 @@ void CodeTree::set_type_rcd_ctor_info(TypeRcd& rcd){
     bool explicit_def_ctor;
     bool implicit_def_ctor;
     bool public_dtor;
+    int assignable;
     int n_def_ctor_decls;
     const CodeTree* tree;
-  } data = {false, true, true, 0, this};
+  } data = {false, true, true, true, 0, this};
 
   clang_visitChildren(rcd.cursor, [](CXCursor cursor, CXCursor, CXClientData data_){
     auto& data = *static_cast<data_t*>(data_);
@@ -950,9 +987,10 @@ void CodeTree::set_type_rcd_ctor_info(TypeRcd& rcd){
         data.public_dtor = false;
       }
     }
+    
     return CXChildVisit_Continue;
   }, &data);
-
+  
   bool finalize_vetoed = false;
   auto it = find(finalizers_to_veto_.begin(), finalizers_to_veto_.end(), rcd.type_name);
   if(it != finalizers_to_veto_.end()){
@@ -3174,3 +3212,5 @@ void CodeTree::set_mapped_types(const std::vector<std::string>& name_map){
     }
   }
 }
+
+

src/libclang-ext.cpp

@@ -267,3 +267,4 @@ bool same_type(CXType t1, CXType t2){
   //Falling back to name comparison:
   return (fully_qualified_name(t1) == fully_qualified_name(t2));
 }
+

test/TestVarField/A.cxx

@@ -5,7 +5,11 @@ int global_int = 1;
 A global_A(10);
 const A global_A_const(11);
 C global_C(1);
-
+NotAssignale global_NotAssignable;
+NotAssignale2 global_NotAssignable2;
+NoCopyCtor global_NoCopyCtor;
+PrivateCopyOp global_PrivateCopyOp;
+NoMoveAssignment global_NoMoveAssignment;
 
 namespace ns{
   int A::static_field = 2;

test/TestVarField/A.h

@@ -5,6 +5,30 @@ struct B{
   int field;
 };
 
+struct NotAssignale {
+  NotAssignale& operator=(const NotAssignale& a) = delete;
+};
+
+struct NotAssignale2 {
+  NotAssignale2& operator=(const NotAssignale2&& a) = delete;
+};
+
+struct NoCopyCtor {
+  NoCopyCtor() {}
+  NoCopyCtor(const NoCopyCtor&)  = delete;
+};
+
+struct NoMoveAssignment {
+  NoMoveAssignment& operator=(NoMoveAssignment&&) = delete;
+  NoMoveAssignment& operator=(const NoMoveAssignment&) { return *this; };
+};
+
+class PrivateCopyOp {
+  PrivateCopyOp& operator=(const PrivateCopyOp& a){
+    return *this;
+  }
+};
+
 
 struct A {
   A(int x = 1): field_int(x), field_int_const(3), field_B(2*x){}
@@ -24,6 +48,12 @@ extern int global_int;
 extern A global_A;
 extern const A global_A_const;
 extern C global_C;
+extern NotAssignale global_NotAssignable;
+extern NotAssignale2 global_NotAssignable2;
+extern NoMoveAssignment global_NoMoveAssignment;
+extern NoCopyCtor global_NoCopyCtor;
+extern PrivateCopyOp global_PrivateCopyOp;
+
 
 namespace ns{
   struct A {

test/TestVarField/runTestVarFieldOn.jl

@@ -13,7 +13,21 @@ function runtest()
         @test :C ∈ names(TestVarFieldOn, all=true)
         @test :global_C ∈ names(TestVarFieldOn, all=true)
         @test :global_C! ∈ names(TestVarFieldOn, all=true)
-       
+
+        @test :global_NoCopyCtor ∈ names(TestVarFieldOn, all=true)
+        @test :global_NoCopyCtor! ∈ names(TestVarFieldOn, all=true)
+
+        @test :global_NotAssignable ∈ names(TestVarFieldOn, all=true)
+        @test :global_NotAssignable! ∉ names(TestVarFieldOn, all=true)
+
+        @test :global_NotAssignable2 ∈ names(TestVarFieldOn, all=true)
+        @test :global_NotAssignable2! ∉ names(TestVarFieldOn, all=true)
+        
+        @test :global_PrivateCopyOp ∈ names(TestVarFieldOn, all=true)
+        @test :global_PrivateCopyOp! ∉ names(TestVarFieldOn, all=true)
+
+        @test :global_NoMoveAssignment ∈ names(TestVarFieldOn, all=true)
+        
         a = TestVarFieldOn.A()
 
         @test TestVarFieldOn.field_int(a) == 1