]> granicus.if.org Git - clang/commitdiff
Added ASTs to destructor decl AST for default destruction of object's
authorFariborz Jahanian <fjahanian@apple.com>
Wed, 15 Jul 2009 22:34:08 +0000 (22:34 +0000)
committerFariborz Jahanian <fjahanian@apple.com>
Wed, 15 Jul 2009 22:34:08 +0000 (22:34 +0000)
base/members.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@75849 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/AST/DeclCXX.h
include/clang/Parse/Action.h
lib/AST/DeclCXX.cpp
lib/AST/DeclPrinter.cpp
lib/Parse/ParseCXXInlineMethods.cpp
lib/Parse/Parser.cpp
lib/Sema/Sema.h
lib/Sema/SemaDeclCXX.cpp

index ff0dd676aa715c9d066ffc5960be2870f3c1e0b4..af4976df7629a142b61a7f308bde983b924f83c9 100644 (file)
@@ -895,7 +895,16 @@ class CXXDestructorDecl : public CXXMethodDecl {
   /// explicitly defaulted (i.e., defined with " = default") will have
   /// @c !Implicit && ImplicitlyDefined.
   bool ImplicitlyDefined : 1;
-
+  
+  /// Support for base and member destruction.
+  /// BaseOrMemberDestructions - The arguments used to destruct the base 
+  /// or member.
+  // FIXME. May want to use a new class as CXXBaseOrMemberInitializer has
+  // more info. than is needed. At the least, CXXBaseOrMemberInitializer need
+  // be renamed to something neutral.
+  CXXBaseOrMemberInitializer **BaseOrMemberDestructions;
+  unsigned NumBaseOrMemberDestructions;
+  
   CXXDestructorDecl(CXXRecordDecl *RD, SourceLocation L,
                     DeclarationName N, QualType T,
                     bool isInline, bool isImplicitlyDeclared)
@@ -928,6 +937,34 @@ public:
     ImplicitlyDefined = ID; 
   }
 
+  /// destr_iterator - Iterates through the member/base destruction list.
+  typedef CXXBaseOrMemberInitializer **destr_iterator;
+  
+  /// destr_const_iterator - Iterates through the member/base destruction list.
+  typedef CXXBaseOrMemberInitializer * const * destr_const_iterator;
+  
+  /// destr_begin() - Retrieve an iterator to the first destructed member/base.
+  destr_iterator       destr_begin()       { return BaseOrMemberDestructions; }
+  /// destr_begin() - Retrieve an iterator to the first destructed member/base.
+  destr_const_iterator destr_begin() const { return BaseOrMemberDestructions; }
+  
+  /// destr_end() - Retrieve an iterator past the last destructed member/base.
+  destr_iterator       destr_end()       { 
+    return BaseOrMemberDestructions + NumBaseOrMemberDestructions; 
+  }
+  /// destr_end() - Retrieve an iterator past the last destructed member/base.
+  destr_const_iterator destr_end() const { 
+    return BaseOrMemberDestructions + NumBaseOrMemberDestructions; 
+  }
+  
+  /// getNumArgs - Determine the number of arguments used to
+  /// destruct the member or base.
+  unsigned getNumBaseOrMemberDestructions() const { 
+    return NumBaseOrMemberDestructions; 
+  }
+  
+  void setBaseOrMemberDestructions(ASTContext &C);
+                        
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { 
     return D->getKind() == CXXDestructor;
index b88ea17a675bf4b5e84213cb745ea41bae899fbf..1f6780e1fe261af56ed5fd8a8b4265e7515fc582 100644 (file)
@@ -1233,7 +1233,7 @@ public:
                                     MemInitTy **MemInits, unsigned NumMemInits){
   }
  
- virtual void ActOnDefaultInitializers(DeclPtrTy ConstructorDecl) {}
+ virtual void ActOnDefaultCDtorInitializers(DeclPtrTy CDtorDecl) {}
 
   /// ActOnFinishCXXMemberSpecification - Invoked after all member declarators
   /// are parsed but *before* parsing of inline method definitions.
index 674e98a2657a245f7c4a18b06286e4873430ce36..57ac611b2ca24cfc131cf15fa90e0ec66551bcca 100644 (file)
@@ -477,6 +477,50 @@ CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
                                    isImplicitlyDeclared);
 }
 
+void
+CXXDestructorDecl::setBaseOrMemberDestructions(ASTContext &C) {
+  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(getDeclContext());
+  llvm::SmallVector<CXXBaseOrMemberInitializer*, 32> AllToDestruct;
+  for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
+       E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
+    CXXBaseOrMemberInitializer *Member = 
+      new CXXBaseOrMemberInitializer(VBase->getType(), 0, 0,SourceLocation());
+    AllToDestruct.push_back(Member);
+  }
+  for (CXXRecordDecl::base_class_iterator Base =
+       ClassDecl->bases_begin(),
+       E = ClassDecl->bases_end(); Base != E; ++Base) {
+    if (Base->isVirtual())
+      continue;
+    CXXBaseOrMemberInitializer *Member = 
+      new CXXBaseOrMemberInitializer(Base->getType(), 0, 0, SourceLocation());
+    AllToDestruct.push_back(Member);
+  }
+  // non-static data members.
+  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
+       E = ClassDecl->field_end(); Field != E; ++Field) {
+    QualType FieldType = C.getCanonicalType((*Field)->getType());
+    while (const ArrayType *AT = C.getAsArrayType(FieldType))
+      FieldType = AT->getElementType();
+    
+    if (FieldType->getAsRecordType()) {
+      CXXBaseOrMemberInitializer *Member = 
+        new CXXBaseOrMemberInitializer((*Field), 0, 0, SourceLocation());
+      AllToDestruct.push_back(Member);
+    }
+  }
+  
+  unsigned NumDestructions = AllToDestruct.size();
+  if (NumDestructions > 0) {
+    NumBaseOrMemberDestructions = NumDestructions;
+    BaseOrMemberDestructions = 
+      new (C) CXXBaseOrMemberInitializer*[NumDestructions];
+    // Insert in reverse order.
+    for (int Idx = NumDestructions-1, i=0 ; Idx >= 0; --Idx)
+      BaseOrMemberDestructions[i++] = AllToDestruct[Idx];
+  }
+}
+
 void
 CXXConstructorDecl::setBaseOrMemberInitializers(
                                     ASTContext &C,
index c7ad8d0a7113fcddc28525317b5e47035fe9db33..84ae72977e6e4eb88bd7d949828804187e3bd168 100644 (file)
@@ -374,6 +374,36 @@ void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
         }
       }
     }
+    else if (CXXDestructorDecl *DDecl = dyn_cast<CXXDestructorDecl>(D)) {
+      if (DDecl->getNumBaseOrMemberDestructions() > 0) {
+        // FIXME. This is strictly for visualization of destructor's AST for
+        // how base/members are destructed. It has no other validity.
+        assert (D->isThisDeclarationADefinition() && "Destructor with dtor-list");
+        Proto += " : ";
+        for (CXXDestructorDecl::destr_const_iterator B = DDecl->destr_begin(), 
+             E = DDecl->destr_end();
+             B != E; ++B) {
+          CXXBaseOrMemberInitializer * BMInitializer = (*B);
+          if (B != DDecl->destr_begin())
+            Proto += ", ";
+
+          if (BMInitializer->isMemberInitializer()) {
+            FieldDecl *FD = BMInitializer->getMember();
+            Proto += "~";
+            Proto += FD->getNameAsString();
+          }
+          else // FIXME. skip dependent types for now.
+            if (const RecordType *RT = 
+                BMInitializer->getBaseClass()->getAsRecordType()) {
+              const CXXRecordDecl *BaseDecl = 
+                cast<CXXRecordDecl>(RT->getDecl());
+              Proto += "~";
+              Proto += BaseDecl->getNameAsString();
+            }
+          Proto += "()";
+        }
+      }
+    }
     else
       AFT->getResultType().getAsStringInternal(Proto, Policy);
   } else {
index 8dcf24f86a51ac4e5c476e8d303a39bcba0e5c89..3bb9c3eb9c2a8134092a080f7cca1d7b3d5ce8d7 100644 (file)
@@ -172,7 +172,7 @@ void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
     if (Tok.is(tok::colon))
       ParseConstructorInitializer(LM.D);
     else
-      Actions.ActOnDefaultInitializers(LM.D);
+      Actions.ActOnDefaultCDtorInitializers(LM.D);
 
     // FIXME: What if ParseConstructorInitializer doesn't leave us with a '{'??
     ParseFunctionStatementBody(LM.D);
index bac3a86dc475222af8cb5d6d725fc1957de992f9..e7b0f337320bc527698dd169fbfdc9b890247cdb 100644 (file)
@@ -666,7 +666,7 @@ Parser::DeclPtrTy Parser::ParseFunctionDefinition(Declarator &D,
   if (Tok.is(tok::colon))
     ParseConstructorInitializer(Res);
   else
-    Actions.ActOnDefaultInitializers(Res);
+    Actions.ActOnDefaultCDtorInitializers(Res);
 
   return ParseFunctionStatementBody(Res);
 }
index e01bf23ce6a132f828f7d2898e895e16284f88d2..f17b77baaa7ba6b3fa164915192a03da946ab781 100644 (file)
@@ -1468,7 +1468,7 @@ public:
                                                     SourceLocation MemberLoc,
                                                     IdentifierInfo &Member,
                                                     DeclPtrTy ImplDecl);
-  virtual void ActOnDefaultInitializers(DeclPtrTy ConstructorDecl);
+  virtual void ActOnDefaultCDtorInitializers(DeclPtrTy CDtorDecl);
   bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
                                FunctionDecl *FDecl,
                                const FunctionProtoType *Proto,
index 7d039dc2d675d7fee6fa577637f5b869cde0b30d..c62858ac73028c0994343800bd38c95408570b73 100644 (file)
@@ -902,15 +902,18 @@ void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl,
   }
 }
 
-void Sema::ActOnDefaultInitializers(DeclPtrTy ConstructorDecl) {
-  if (!ConstructorDecl)
+void Sema::ActOnDefaultCDtorInitializers(DeclPtrTy CDtorDecl) {
+  if (!CDtorDecl)
     return;
   
   if (CXXConstructorDecl *Constructor 
-      = dyn_cast<CXXConstructorDecl>(ConstructorDecl.getAs<Decl>()))
+      = dyn_cast<CXXConstructorDecl>(CDtorDecl.getAs<Decl>()))
     Constructor->setBaseOrMemberInitializers(Context, 
                                            (CXXBaseOrMemberInitializer **)0, 0);
-                                           
+  else 
+    if (CXXDestructorDecl *Destructor 
+        = dyn_cast<CXXDestructorDecl>(CDtorDecl.getAs<Decl>()))
+      Destructor->setBaseOrMemberDestructions(Context);
 }
 
 namespace {