Unifies the name-lookup mechanisms used in various parts of the AST

and separates lexical name lookup from qualified name lookup. In
particular:
  * Make DeclContext the central data structure for storing and
    looking up declarations within existing declarations, e.g., members
    of structs/unions/classes, enumerators in C++0x enums, members of
    C++ namespaces, and (later) members of Objective-C
    interfaces/implementations. DeclContext uses a lazily-constructed
    data structure optimized for fast lookup (array for small contexts,
    hash table for larger contexts). 

  * Implement C++ qualified name lookup in terms of lookup into
    DeclContext.

  * Implement C++ unqualified name lookup in terms of
    qualified+unqualified name lookup (since unqualified lookup is not
    purely lexical in C++!)

  * Limit the use of the chains of declarations stored in
    IdentifierInfo to those names declared lexically.

  * Eliminate CXXFieldDecl, collapsing its behavior into
    FieldDecl. (FieldDecl is now a ScopedDecl).

  * Make RecordDecl into a DeclContext and eliminates its
    Members/NumMembers fields (since one can just iterate through the
    DeclContext to get the fields).

llvm-svn: 60878

6 files changed, 79 insertions, 55 deletions

diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index d93bccd2ff2..67c60aae07c 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -289,10 +289,11 @@ llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty,
   llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators;
 
   // Create DIEnumerator elements for each enumerator.
-  for (EnumConstantDecl *Elt = Decl->getEnumConstantList(); Elt;
-       Elt = dyn_cast_or_null<EnumConstantDecl>(Elt->getNextDeclarator())) {
-    Enumerators.push_back(DebugFactory.CreateEnumerator(Elt->getNameAsString(),
-                                            Elt->getInitVal().getZExtValue()));
+  for (EnumDecl::enumerator_iterator Enum = Decl->enumerator_begin(),
+                                  EnumEnd = Decl->enumerator_end();
+       Enum != EnumEnd; ++Enum) {
+    Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getNameAsString(),
+                                            Enum->getInitVal().getZExtValue()));
   }
   
   // Return a CompositeType for the enum itself.
diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp
index 65f8a1a2e41..834d7483baf 100644
--- a/clang/lib/CodeGen/CGExprAgg.cpp
+++ b/clang/lib/CodeGen/CGExprAgg.cpp
@@ -434,20 +434,24 @@ void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
   // the optimizer, especially with bitfields.
   unsigned NumInitElements = E->getNumInits();
   RecordDecl *SD = E->getType()->getAsRecordType()->getDecl();
-  unsigned NumMembers = SD->getNumMembers() - SD->hasFlexibleArrayMember();
   unsigned CurInitVal = 0;
   bool isUnion = E->getType()->isUnionType();
   
   // Here we iterate over the fields; this makes it simpler to both
   // default-initialize fields and skip over unnamed fields.
-  for (unsigned CurFieldNo = 0; CurFieldNo != NumMembers; ++CurFieldNo) {
-    FieldDecl *CurField = SD->getMember(CurFieldNo);
-    if (CurField->getIdentifier() == 0) {
+  for (RecordDecl::field_iterator Field = SD->field_begin(),
+                               FieldEnd = SD->field_end();
+       Field != FieldEnd; ++Field) {
+    // We're done once we hit the flexible array member
+    if (Field->getType()->isIncompleteArrayType())
+      break;
+
+    if (Field->getIdentifier() == 0) {
       // Initializers can't initialize unnamed fields, e.g. "int : 20;"
       continue;
     }
     // FIXME: volatility
-    LValue FieldLoc = CGF.EmitLValueForField(DestPtr, CurField, isUnion,0);
+    LValue FieldLoc = CGF.EmitLValueForField(DestPtr, *Field, isUnion,0);
     if (CurInitVal < NumInitElements) {
       // Store the initializer into the field
       // This will probably have to get a bit smarter when we support
@@ -455,7 +459,7 @@ void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
       EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc);
     } else {
       // We're out of initalizers; default-initialize to null
-      EmitNullInitializationToLValue(FieldLoc, CurField->getType());
+      EmitNullInitializationToLValue(FieldLoc, Field->getType());
     }
 
     // Unions only initialize one field.
diff --git a/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp
index 7f294e29965..52d99dc60e6 100644
--- a/clang/lib/CodeGen/CGExprConstant.cpp
+++ b/clang/lib/CodeGen/CGExprConstant.cpp
@@ -187,16 +187,17 @@ public:
     unsigned EltNo = 0;  // Element no in ILE
     int FieldNo = 0; // Field no in RecordDecl
     bool RewriteType = false;
-    while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) {
-      FieldDecl* curField = RD->getMember(FieldNo);
+    for (RecordDecl::field_iterator Field = RD->field_begin(),
+                                 FieldEnd = RD->field_end();
+         EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) {
       FieldNo++;
-      if (!curField->getIdentifier())
+      if (!Field->getIdentifier())
         continue;
 
-      if (curField->isBitField()) {
-        InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo));
+      if (Field->isBitField()) {
+        InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo));
       } else {
-        unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField);
+        unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field);
         llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF);
         RewriteType |= (C->getType() != Elts[FieldNo]->getType());
         Elts[FieldNo] = C;
@@ -223,8 +224,10 @@ public:
     // Find the field decl we're initializing, if any
     int FieldNo = 0; // Field no in RecordDecl
     FieldDecl* curField = 0;
-    while (FieldNo < RD->getNumMembers()) {
-      curField = RD->getMember(FieldNo);
+    for (RecordDecl::field_iterator Field = RD->field_begin(),
+                                 FieldEnd = RD->field_end();
+         Field != FieldEnd; ++Field) {
+      curField = *Field;
       FieldNo++;
       if (curField->getIdentifier())
         break;
diff --git a/clang/lib/CodeGen/CGObjCMac.cpp b/clang/lib/CodeGen/CGObjCMac.cpp
index 013b0f9cc3e..201f53e34d0 100644
--- a/clang/lib/CodeGen/CGObjCMac.cpp
+++ b/clang/lib/CodeGen/CGObjCMac.cpp
@@ -2373,12 +2373,15 @@ ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
   RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
                                       SourceLocation(),
                                       &Ctx.Idents.get("_objc_super"));  
-  FieldDecl *FieldDecls[2];
-  FieldDecls[0] = FieldDecl::Create(Ctx, SourceLocation(), 0, 
-                                    Ctx.getObjCIdType());
-  FieldDecls[1] = FieldDecl::Create(Ctx, SourceLocation(), 0,
-                                    Ctx.getObjCClassType());
-  RD->defineBody(Ctx, FieldDecls, 2);
+  RD->addDecl(Ctx, 
+              FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 
+                                Ctx.getObjCIdType(), 0, false, 0), 
+              true);
+  RD->addDecl(Ctx, 
+              FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
+                                Ctx.getObjCClassType(), 0, false, 0), 
+              true);
+  RD->completeDefinition(Ctx);
 
   SuperCTy = Ctx.getTagDeclType(RD);
   SuperPtrCTy = Ctx.getPointerType(SuperCTy);
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 82e732163bd..e83d2cd2930 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -775,21 +775,20 @@ llvm::Function *CodeGenModule::getMemSetFn() {
 
 static void appendFieldAndPadding(CodeGenModule &CGM,
                                   std::vector<llvm::Constant*>& Fields,
-                                  int FieldNo, llvm::Constant* Field,
+                                  FieldDecl *FieldD, FieldDecl *NextFieldD,
+                                  llvm::Constant* Field,
                                   RecordDecl* RD, const llvm::StructType *STy)
 {
   // Append the field.
   Fields.push_back(Field);
   
-  int StructFieldNo = 
-    CGM.getTypes().getLLVMFieldNo(RD->getMember(FieldNo));
+  int StructFieldNo = CGM.getTypes().getLLVMFieldNo(FieldD);
   
   int NextStructFieldNo;
-  if (FieldNo + 1 == RD->getNumMembers()) {
+  if (!NextFieldD) {
     NextStructFieldNo = STy->getNumElements();
   } else {
-    NextStructFieldNo = 
-      CGM.getTypes().getLLVMFieldNo(RD->getMember(FieldNo + 1));
+    NextStructFieldNo = CGM.getTypes().getLLVMFieldNo(NextFieldD);
   }
   
   // Append padding
@@ -841,29 +840,38 @@ GetAddrOfConstantCFString(const std::string &str) {
     cast<llvm::StructType>(getTypes().ConvertType(CFTy));
 
   std::vector<llvm::Constant*> Fields;
-  
-  
+  RecordDecl::field_iterator Field = CFRD->field_begin();
+
   // Class pointer.
-  appendFieldAndPadding(*this, Fields, 0, CFConstantStringClassRef, CFRD, STy);
+  FieldDecl *CurField = *Field++;
+  FieldDecl *NextField = *Field++;
+  appendFieldAndPadding(*this, Fields, CurField, NextField,
+                        CFConstantStringClassRef, CFRD, STy);
   
   // Flags.
+  CurField = NextField;
+  NextField = *Field++;
   const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
-  appendFieldAndPadding(*this, Fields, 1, llvm::ConstantInt::get(Ty, 0x07C8), 
-                        CFRD, STy);
+  appendFieldAndPadding(*this, Fields, CurField, NextField,
+                        llvm::ConstantInt::get(Ty, 0x07C8), CFRD, STy);
     
   // String pointer.
+  CurField = NextField;
+  NextField = *Field++;
   llvm::Constant *C = llvm::ConstantArray::get(str);
   C = new llvm::GlobalVariable(C->getType(), true, 
                                llvm::GlobalValue::InternalLinkage,
                                C, ".str", &getModule());
-  appendFieldAndPadding(*this, Fields, 2, 
+  appendFieldAndPadding(*this, Fields, CurField, NextField,
                         llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2),
                         CFRD, STy);
   
   // String length.
+  CurField = NextField;
+  NextField = 0;
   Ty = getTypes().ConvertType(getContext().LongTy);
-  appendFieldAndPadding(*this, Fields, 3, llvm::ConstantInt::get(Ty, str.length()),
-                        CFRD, STy);
+  appendFieldAndPadding(*this, Fields, CurField, NextField,
+                        llvm::ConstantInt::get(Ty, str.length()), CFRD, STy);
   
   // The struct.
   C = llvm::ConstantStruct::get(STy, Fields);
diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 85b10399a41..8918671332d 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -392,7 +392,7 @@ const llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) {
   } else if (TD->isUnion()) {
     // Just use the largest element of the union, breaking ties with the
     // highest aligned member.
-    if (RD->getNumMembers() != 0) {
+    if (RD->field_begin() != RD->field_end()) {
       RecordOrganizer RO(*this, *RD);
       
       RO.layoutUnionFields(Context.getASTRecordLayout(RD));
@@ -478,16 +478,17 @@ void RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) {
   uint64_t llvmSize = 0;
   // FIXME: Make this a SmallVector
   std::vector<const llvm::Type*> LLVMFields;
-  int NumMembers = RD.getNumMembers();
 
-  for (int curField = 0; curField < NumMembers; curField++) {
-    const FieldDecl *FD = RD.getMember(curField);
+  unsigned curField = 0;
+  for (RecordDecl::field_iterator Field = RD.field_begin(),
+                               FieldEnd = RD.field_end();
+       Field != FieldEnd; ++Field) {
     uint64_t offset = RL.getFieldOffset(curField);
-    const llvm::Type *Ty = CGT.ConvertTypeRecursive(FD->getType());
+    const llvm::Type *Ty = CGT.ConvertTypeRecursive(Field->getType());
     uint64_t size = CGT.getTargetData().getABITypeSizeInBits(Ty);
 
-    if (FD->isBitField()) {
-      Expr *BitWidth = FD->getBitWidth();
+    if (Field->isBitField()) {
+      Expr *BitWidth = Field->getBitWidth();
       llvm::APSInt FieldSize(32);
       bool isBitField =
         BitWidth->isIntegerConstantExpr(FieldSize, CGT.getContext());
@@ -498,8 +499,8 @@ void RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) {
       // Bitfield field info is different from other field info;
       // it actually ignores the underlying LLVM struct because
       // there isn't any convenient mapping.
-      CGT.addFieldInfo(FD, offset / size);
-      CGT.addBitFieldInfo(FD, offset % size, BitFieldSize);
+      CGT.addFieldInfo(*Field, offset / size);
+      CGT.addBitFieldInfo(*Field, offset % size, BitFieldSize);
     } else {
       // Put the element into the struct. This would be simpler
       // if we didn't bother, but it seems a bit too strange to
@@ -510,9 +511,10 @@ void RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) {
       }
 
       llvmSize += size;
-      CGT.addFieldInfo(FD, LLVMFields.size());
+      CGT.addFieldInfo(*Field, LLVMFields.size());
       LLVMFields.push_back(Ty);
     }
+    ++curField;
   }
 
   while (llvmSize < RL.getSize()) {
@@ -528,21 +530,24 @@ void RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) {
 /// corresponding llvm struct type.  This should be invoked only after
 /// all fields are added.
 void RecordOrganizer::layoutUnionFields(const ASTRecordLayout &RL) {
-  for (int curField = 0; curField < RD.getNumMembers(); curField++) {
-    const FieldDecl *FD = RD.getMember(curField);
+  unsigned curField = 0;
+  for (RecordDecl::field_iterator Field = RD.field_begin(),
+                               FieldEnd = RD.field_end();
+       Field != FieldEnd; ++Field) {
     // The offset should usually be zero, but bitfields could be strange
     uint64_t offset = RL.getFieldOffset(curField);
 
-    if (FD->isBitField()) {
-      Expr *BitWidth = FD->getBitWidth();
+    if (Field->isBitField()) {
+      Expr *BitWidth = Field->getBitWidth();
       uint64_t BitFieldSize =  
         BitWidth->getIntegerConstantExprValue(CGT.getContext()).getZExtValue();
 
-      CGT.addFieldInfo(FD, 0);
-      CGT.addBitFieldInfo(FD, offset, BitFieldSize);
+      CGT.addFieldInfo(*Field, 0);
+      CGT.addBitFieldInfo(*Field, offset, BitFieldSize);
     } else {
-      CGT.addFieldInfo(FD, 0);
+      CGT.addFieldInfo(*Field, 0);
     }
+    ++curField;
   }
 
   // This looks stupid, but it is correct in the sense that