diff --git a/lib/AST/CFG.cpp b/lib/AST/CFG.cpp
index 2eea649..2a79355 100644
--- a/lib/AST/CFG.cpp
+++ b/lib/AST/CFG.cpp
@@ -50,32 +50,6 @@
   return D->getLocation();  
 }
   
-class VISIBILITY_HIDDEN UnaryDeclStmt : public DeclStmt {
-  Stmt* Ex;
-public:
-  UnaryDeclStmt(ScopedDecl* D)
-  : DeclStmt(D, D->getLocation(), GetEndLoc(D)), Ex(0) {
-    if (VarDecl* VD = dyn_cast<VarDecl>(D))
-      Ex = VD->getInit();
-  }
-  
-  virtual ~UnaryDeclStmt() {}
-  virtual void Destroy(ASTContext& Ctx) { assert(false && "Do not call"); }
-  
-  virtual child_iterator child_begin() {
-    return Ex ? &Ex : 0;
-  }  
-  virtual child_iterator child_end() {
-    return Ex ? &Ex + 1 : 0;
-  }  
-  virtual decl_iterator decl_begin() {
-    return TheDecl;
-  }  
-  virtual decl_iterator decl_end() {
-    return TheDecl ? TheDecl->getNextDeclarator() : 0;
-  }
-};
-  
 /// CFGBuilder - This class implements CFG construction from an AST.
 ///   The builder is stateful: an instance of the builder should be used to only
 ///   construct a single CFG.
@@ -395,16 +369,25 @@
           Buf.push_back(*DI);
         
         for (BufTy::reverse_iterator I=Buf.rbegin(), E=Buf.rend(); I!=E; ++I) {
-          // Get the alignment of UnaryDeclStmt, padding out to >=8 bytes.
-          unsigned A = llvm::AlignOf<UnaryDeclStmt>::Alignment < 8
-                       ? 8 : llvm::AlignOf<UnaryDeclStmt>::Alignment;
+          // Get the alignment of the new DeclStmt, padding out to >=8 bytes.
+          unsigned A = llvm::AlignOf<DeclStmt>::Alignment < 8
+                       ? 8 : llvm::AlignOf<DeclStmt>::Alignment;
           
-          // Allocate the UnaryDeclStmt using the BumpPtrAllocator.  It will
-          // get automatically freed with the CFG.
-          void* Mem = cfg->getAllocator().Allocate(sizeof(UnaryDeclStmt), A);
+          // Allocate the DeclStmt using the BumpPtrAllocator.  It will
+          // get automatically freed with the CFG.  Note that even though
+          // we are using a DeclGroupOwningRef that wraps a singe Decl*,
+          // that Decl* will not get deallocated because the destroy method
+          // of DG is never called.
+          DeclGroupOwningRef DG(*I);
+          ScopedDecl* D = *I;
+          void* Mem = cfg->getAllocator().Allocate(sizeof(DeclStmt), A);
+          
+          DeclStmt* DS = new (Mem) DeclStmt(DG, D->getLocation(),
+                                            GetEndLoc(D));
+          
           // Append the fake DeclStmt to block.
-          Block->appendStmt(new (Mem) UnaryDeclStmt(*I));
-          B = WalkAST_VisitDeclSubExpr(*I);
+          Block->appendStmt(DS);
+          B = WalkAST_VisitDeclSubExpr(D);
         }
         return B;
       }
diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp
index fbb369f..f30e105 100644
--- a/lib/AST/Stmt.cpp
+++ b/lib/AST/Stmt.cpp
@@ -55,7 +55,7 @@
 }
 
 void DeclStmt::Destroy(ASTContext& C) {
-  TheDecl->Destroy(C);
+  DG.Destroy(C);
   delete this;
 }
 
@@ -188,16 +188,12 @@
 //===----------------------------------------------------------------------===//
 
 // DeclStmt
-Stmt::child_iterator DeclStmt::child_begin() { return TheDecl; }
-Stmt::child_iterator DeclStmt::child_end() { return child_iterator(); }
-
-DeclStmt::decl_iterator& DeclStmt::decl_iterator::operator++() {
-  D = D->getNextDeclarator();
-  return *this;
+Stmt::child_iterator DeclStmt::child_begin() {
+  return StmtIterator(DG.begin(), DG.end());
 }
 
-bool DeclStmt::hasSolitaryDecl() const {
-  return TheDecl->getNextDeclarator() == 0;
+Stmt::child_iterator DeclStmt::child_end() {
+  return StmtIterator(DG.end(), DG.end());
 }
 
 // NullStmt
diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index b226bdf..f72800d 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -478,14 +478,14 @@
 void DeclStmt::EmitImpl(Serializer& S) const {
   S.Emit(StartLoc);
   S.Emit(EndLoc);
-  S.EmitOwnedPtr(TheDecl);
+  S.Emit(DG);
 }
     
 DeclStmt* DeclStmt::CreateImpl(Deserializer& D, ASTContext& C) {
   SourceLocation StartLoc = SourceLocation::ReadVal(D);
-  SourceLocation EndLoc = SourceLocation::ReadVal(D);  
-  ScopedDecl* decl = cast<ScopedDecl>(D.ReadOwnedPtr<Decl>(C));  
-  return new DeclStmt(decl, StartLoc, EndLoc);
+  SourceLocation EndLoc = SourceLocation::ReadVal(D); 
+  DeclGroupOwningRef DG;
+  return new DeclStmt(DG.Read(D, C), StartLoc, EndLoc);
 }
 
 void DeclRefExpr::EmitImpl(Serializer& S) const {
diff --git a/lib/AST/StmtViz.cpp b/lib/AST/StmtViz.cpp
index 6790efb..1316d35 100644
--- a/lib/AST/StmtViz.cpp
+++ b/lib/AST/StmtViz.cpp
@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/StmtGraphTraits.h"
+#include "clang/AST/Decl.h"
 #include "llvm/Support/GraphWriter.h"
 #include <sstream>
 
diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp
index 68b36ba..f75758e 100644
--- a/lib/Sema/SemaStmt.cpp
+++ b/lib/Sema/SemaStmt.cpp
@@ -42,7 +42,28 @@
     return true;
   
   ScopedDecl *SD = cast<ScopedDecl>(static_cast<Decl *>(decl));
-  return new DeclStmt(SD, StartLoc, EndLoc);
+  
+  
+  // This is a temporary hack until we are always passing around
+  // DeclGroupRefs.
+  llvm::SmallVector<Decl*, 10> decls;
+  while (SD) { 
+    ScopedDecl* d = SD;
+    SD = SD->getNextDeclarator();
+    d->setNextDeclarator(0);
+    decls.push_back(d);
+  }
+
+  assert (!decls.empty());
+    
+  if (decls.size() == 1) {
+    DeclGroupOwningRef DG(*decls.begin());                      
+    return new DeclStmt(DG, StartLoc, EndLoc);
+  }
+  else {
+    DeclGroupOwningRef DG(DeclGroup::Create(Context, decls.size(), &decls[0]));                      
+    return new DeclStmt(DG, StartLoc, EndLoc);
+  }
 }
 
 Action::StmtResult