vendor/clang/clang-r84119

1 files changed, 709 insertions, 773 deletions

diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 6f2fc5e0c434b..dd877c16fba79 100644
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -12,18 +12,20 @@
 //
 //===----------------------------------------------------------------------===//
 #include "Sema.h"
-#include "SemaInherit.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/Parse/DeclSpec.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <set>
 #include <vector>
 #include <iterator>
@@ -34,7 +36,6 @@ using namespace clang;
 
 typedef llvm::SmallVector<UsingDirectiveDecl*, 4> UsingDirectivesTy;
 typedef llvm::DenseSet<NamespaceDecl*> NamespaceSet;
-typedef llvm::SmallVector<Sema::LookupResult, 3> LookupResultsTy;
 
 /// UsingDirAncestorCompare - Implements strict weak ordering of
 /// UsingDirectives. It orders them by address of its common ancestor.
@@ -59,7 +60,7 @@ struct UsingDirAncestorCompare {
 /// AddNamespaceUsingDirectives - Adds all UsingDirectiveDecl's to heap UDirs
 /// (ordered by common ancestors), found in namespace NS,
 /// including all found (recursively) in their nominated namespaces.
-void AddNamespaceUsingDirectives(ASTContext &Context, 
+void AddNamespaceUsingDirectives(ASTContext &Context,
                                  DeclContext *NS,
                                  UsingDirectivesTy &UDirs,
                                  NamespaceSet &Visited) {
@@ -76,7 +77,7 @@ void AddNamespaceUsingDirectives(ASTContext &Context,
 
 /// AddScopeUsingDirectives - Adds all UsingDirectiveDecl's found in Scope S,
 /// including all found in the namespaces they nominate.
-static void AddScopeUsingDirectives(ASTContext &Context, Scope *S, 
+static void AddScopeUsingDirectives(ASTContext &Context, Scope *S,
                                     UsingDirectivesTy &UDirs) {
   NamespaceSet VisitedNS;
 
@@ -99,189 +100,17 @@ static void AddScopeUsingDirectives(ASTContext &Context, Scope *S,
       NamespaceDecl *Nominated = UD->getNominatedNamespace();
       if (!VisitedNS.count(Nominated)) {
         VisitedNS.insert(Nominated);
-        AddNamespaceUsingDirectives(Context, Nominated, UDirs, 
+        AddNamespaceUsingDirectives(Context, Nominated, UDirs,
                                     /*ref*/ VisitedNS);
       }
     }
   }
 }
 
-/// MaybeConstructOverloadSet - Name lookup has determined that the
-/// elements in [I, IEnd) have the name that we are looking for, and
-/// *I is a match for the namespace. This routine returns an
-/// appropriate Decl for name lookup, which may either be *I or an
-/// OverloadedFunctionDecl that represents the overloaded functions in
-/// [I, IEnd). 
-///
-/// The existance of this routine is temporary; users of LookupResult
-/// should be able to handle multiple results, to deal with cases of
-/// ambiguity and overloaded functions without needing to create a
-/// Decl node.
-template<typename DeclIterator>
-static NamedDecl *
-MaybeConstructOverloadSet(ASTContext &Context, 
-                          DeclIterator I, DeclIterator IEnd) {
-  assert(I != IEnd && "Iterator range cannot be empty");
-  assert(!isa<OverloadedFunctionDecl>(*I) && 
-         "Cannot have an overloaded function");
-
-  if ((*I)->isFunctionOrFunctionTemplate()) {
-    // If we found a function, there might be more functions. If
-    // so, collect them into an overload set.
-    DeclIterator Last = I;
-    OverloadedFunctionDecl *Ovl = 0;
-    for (++Last; 
-         Last != IEnd && (*Last)->isFunctionOrFunctionTemplate(); 
-         ++Last) {
-      if (!Ovl) {
-        // FIXME: We leak this overload set. Eventually, we want to stop
-        // building the declarations for these overload sets, so there will be
-        // nothing to leak.
-        Ovl = OverloadedFunctionDecl::Create(Context, (*I)->getDeclContext(),
-                                             (*I)->getDeclName());
-        NamedDecl *ND = (*I)->getUnderlyingDecl();
-        if (isa<FunctionDecl>(ND))
-          Ovl->addOverload(cast<FunctionDecl>(ND));
-        else
-          Ovl->addOverload(cast<FunctionTemplateDecl>(ND));
-      }
-
-      NamedDecl *ND = (*Last)->getUnderlyingDecl();
-      if (isa<FunctionDecl>(ND))
-        Ovl->addOverload(cast<FunctionDecl>(ND));
-      else
-        Ovl->addOverload(cast<FunctionTemplateDecl>(ND));
-    }
-    
-    // If we had more than one function, we built an overload
-    // set. Return it.
-    if (Ovl)
-      return Ovl;
-  }
-  
-  return *I;
-}
-
-/// Merges together multiple LookupResults dealing with duplicated Decl's.
-static Sema::LookupResult
-MergeLookupResults(ASTContext &Context, LookupResultsTy &Results) {
-  typedef Sema::LookupResult LResult;
-  typedef llvm::SmallPtrSet<NamedDecl*, 4> DeclsSetTy;
-
-  // Remove duplicated Decl pointing at same Decl, by storing them in
-  // associative collection. This might be case for code like:
-  //
-  //    namespace A { int i; }
-  //    namespace B { using namespace A; }
-  //    namespace C { using namespace A; }
-  //
-  //    void foo() {
-  //      using namespace B;
-  //      using namespace C;
-  //      ++i; // finds A::i, from both namespace B and C at global scope
-  //    }
-  //
-  //  C++ [namespace.qual].p3:
-  //    The same declaration found more than once is not an ambiguity
-  //    (because it is still a unique declaration).
-  DeclsSetTy FoundDecls;
-
-  // Counter of tag names, and functions for resolving ambiguity
-  // and name hiding.
-  std::size_t TagNames = 0, Functions = 0, OrdinaryNonFunc = 0;
-
-  LookupResultsTy::iterator I = Results.begin(), End = Results.end();
-
-  // No name lookup results, return early.
-  if (I == End) return LResult::CreateLookupResult(Context, 0);
-
-  // Keep track of the tag declaration we found. We only use this if
-  // we find a single tag declaration.
-  TagDecl *TagFound = 0;
-
-  for (; I != End; ++I) {
-    switch (I->getKind()) {
-    case LResult::NotFound:
-      assert(false &&
-             "Should be always successful name lookup result here.");
-      break;
-
-    case LResult::AmbiguousReference:
-    case LResult::AmbiguousBaseSubobjectTypes:
-    case LResult::AmbiguousBaseSubobjects:
-      assert(false && "Shouldn't get ambiguous lookup here.");
-      break;
-
-    case LResult::Found: {
-      NamedDecl *ND = I->getAsDecl()->getUnderlyingDecl();
-        
-      if (TagDecl *TD = dyn_cast<TagDecl>(ND)) {
-        TagFound = Context.getCanonicalDecl(TD);
-        TagNames += FoundDecls.insert(TagFound)?  1 : 0;
-      } else if (ND->isFunctionOrFunctionTemplate())
-        Functions += FoundDecls.insert(ND)? 1 : 0;
-      else
-        FoundDecls.insert(ND);
-      break;
-    }
-
-    case LResult::FoundOverloaded:
-      for (LResult::iterator FI = I->begin(), FEnd = I->end(); FI != FEnd; ++FI)
-        Functions += FoundDecls.insert(*FI)? 1 : 0;
-      break;
-    }
-  }
-  OrdinaryNonFunc = FoundDecls.size() - TagNames - Functions;
-  bool Ambiguous = false, NameHidesTags = false;
-  
-  if (FoundDecls.size() == 1) {
-    // 1) Exactly one result.
-  } else if (TagNames > 1) {
-    // 2) Multiple tag names (even though they may be hidden by an
-    // object name).
-    Ambiguous = true;
-  } else if (FoundDecls.size() - TagNames == 1) {
-    // 3) Ordinary name hides (optional) tag.
-    NameHidesTags = TagFound;
-  } else if (Functions) {
-    // C++ [basic.lookup].p1:
-    // ... Name lookup may associate more than one declaration with
-    // a name if it finds the name to be a function name; the declarations
-    // are said to form a set of overloaded functions (13.1).
-    // Overload resolution (13.3) takes place after name lookup has succeeded.
-    //
-    if (!OrdinaryNonFunc) {
-      // 4) Functions hide tag names.
-      NameHidesTags = TagFound;
-    } else {
-      // 5) Functions + ordinary names.
-      Ambiguous = true;
-    }
-  } else {
-    // 6) Multiple non-tag names
-    Ambiguous = true;
-  }
-
-  if (Ambiguous)
-    return LResult::CreateLookupResult(Context, 
-                                       FoundDecls.begin(), FoundDecls.size());
-  if (NameHidesTags) {
-    // There's only one tag, TagFound. Remove it.
-    assert(TagFound && FoundDecls.count(TagFound) && "No tag name found?");
-    FoundDecls.erase(TagFound);
-  }
-
-  // Return successful name lookup result.
-  return LResult::CreateLookupResult(Context,
-                                MaybeConstructOverloadSet(Context,
-                                                          FoundDecls.begin(),
-                                                          FoundDecls.end()));
-}
-
 // Retrieve the set of identifier namespaces that correspond to a
 // specific kind of name lookup.
-inline unsigned 
-getIdentifierNamespacesFromLookupNameKind(Sema::LookupNameKind NameKind, 
+inline unsigned
+getIdentifierNamespacesFromLookupNameKind(Sema::LookupNameKind NameKind,
                                           bool CPlusPlus) {
   unsigned IDNS = 0;
   switch (NameKind) {
@@ -300,7 +129,7 @@ getIdentifierNamespacesFromLookupNameKind(Sema::LookupNameKind NameKind,
   case Sema::LookupMemberName:
     IDNS = Decl::IDNS_Member;
     if (CPlusPlus)
-      IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary;    
+      IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary;
     break;
 
   case Sema::LookupNestedNameSpecifierName:
@@ -323,97 +152,81 @@ getIdentifierNamespacesFromLookupNameKind(Sema::LookupNameKind NameKind,
   return IDNS;
 }
 
-Sema::LookupResult
-Sema::LookupResult::CreateLookupResult(ASTContext &Context, NamedDecl *D) {
-  if (D)
-    D = D->getUnderlyingDecl();
-  
-  LookupResult Result;
-  Result.StoredKind = (D && isa<OverloadedFunctionDecl>(D))?
-    OverloadedDeclSingleDecl : SingleDecl;
-  Result.First = reinterpret_cast<uintptr_t>(D);
-  Result.Last = 0;
-  Result.Context = &Context;
-  return Result;
+// Necessary because CXXBasePaths is not complete in Sema.h
+void Sema::LookupResult::deletePaths(CXXBasePaths *Paths) {
+  delete Paths;
 }
 
-/// @brief Moves the name-lookup results from Other to this LookupResult.
-Sema::LookupResult
-Sema::LookupResult::CreateLookupResult(ASTContext &Context, 
-                                       IdentifierResolver::iterator F, 
-                                       IdentifierResolver::iterator L) {
-  LookupResult Result;
-  Result.Context = &Context;
-
-  if (F != L && (*F)->isFunctionOrFunctionTemplate()) {
-    IdentifierResolver::iterator Next = F;
-    ++Next;
-    if (Next != L && (*Next)->isFunctionOrFunctionTemplate()) {
-      Result.StoredKind = OverloadedDeclFromIdResolver;
-      Result.First = F.getAsOpaqueValue();
-      Result.Last = L.getAsOpaqueValue();
-      return Result;
-    }
-  } 
-
-  NamedDecl *D = *F;
-  if (D)
-    D = D->getUnderlyingDecl();
-
-  Result.StoredKind = SingleDecl;
-  Result.First = reinterpret_cast<uintptr_t>(D);
-  Result.Last = 0;
-  return Result;
-}
-
-Sema::LookupResult
-Sema::LookupResult::CreateLookupResult(ASTContext &Context, 
-                                       DeclContext::lookup_iterator F, 
-                                       DeclContext::lookup_iterator L) {
-  LookupResult Result;
-  Result.Context = &Context;
-
-  if (F != L && (*F)->isFunctionOrFunctionTemplate()) {
-    DeclContext::lookup_iterator Next = F;
-    ++Next;
-    if (Next != L && (*Next)->isFunctionOrFunctionTemplate()) {
-      Result.StoredKind = OverloadedDeclFromDeclContext;
-      Result.First = reinterpret_cast<uintptr_t>(F);
-      Result.Last = reinterpret_cast<uintptr_t>(L);
-      return Result;
-    }
-  }
+void Sema::LookupResult::resolveKind() {
+  unsigned N = Decls.size();
 
-  NamedDecl *D = *F;
-  if (D)
-    D = D->getUnderlyingDecl();
-  
-  Result.StoredKind = SingleDecl;
-  Result.First = reinterpret_cast<uintptr_t>(D);
-  Result.Last = 0;
-  return Result;
-}
+  // Fast case: no possible ambiguity.
+  if (N <= 1) return;
 
-/// @brief Determine the result of name lookup.
-Sema::LookupResult::LookupKind Sema::LookupResult::getKind() const {
-  switch (StoredKind) {
-  case SingleDecl:
-    return (reinterpret_cast<Decl *>(First) != 0)? Found : NotFound;
+  // Don't do any extra resolution if we've already resolved as ambiguous.
+  if (Kind == Ambiguous) return;
 
-  case OverloadedDeclSingleDecl:
-  case OverloadedDeclFromIdResolver:
-  case OverloadedDeclFromDeclContext:
-    return FoundOverloaded;
+  llvm::SmallPtrSet<NamedDecl*, 16> Unique;
 
-  case AmbiguousLookupStoresBasePaths:
-    return Last? AmbiguousBaseSubobjectTypes : AmbiguousBaseSubobjects;
+  bool Ambiguous = false;
+  bool HasTag = false, HasFunction = false, HasNonFunction = false;
 
-  case AmbiguousLookupStoresDecls:
-    return AmbiguousReference;
+  unsigned UniqueTagIndex = 0;
+  
+  unsigned I = 0;
+  while (I < N) {
+    NamedDecl *D = Decls[I];
+    assert(D == D->getUnderlyingDecl());
+
+    NamedDecl *CanonD = cast<NamedDecl>(D->getCanonicalDecl());
+    if (!Unique.insert(CanonD)) {
+      // If it's not unique, pull something off the back (and
+      // continue at this index).
+      Decls[I] = Decls[--N];
+    } else if (isa<UnresolvedUsingDecl>(D)) {
+      // FIXME: proper support for UnresolvedUsingDecls.
+      Decls[I] = Decls[--N];
+    } else {
+      // Otherwise, do some decl type analysis and then continue.
+      if (isa<TagDecl>(D)) {
+        if (HasTag)
+          Ambiguous = true;
+        UniqueTagIndex = I;
+        HasTag = true;
+      } else if (D->isFunctionOrFunctionTemplate()) {
+        HasFunction = true;
+      } else {
+        if (HasNonFunction)
+          Ambiguous = true;
+        HasNonFunction = true;
+      }
+      I++;
+    }
   }
 
-  // We can't ever get here.
-  return NotFound;
+  // C++ [basic.scope.hiding]p2:
+  //   A class name or enumeration name can be hidden by the name of
+  //   an object, function, or enumerator declared in the same
+  //   scope. If a class or enumeration name and an object, function,
+  //   or enumerator are declared in the same scope (in any order)
+  //   with the same name, the class or enumeration name is hidden
+  //   wherever the object, function, or enumerator name is visible.
+  // But it's still an error if there are distinct tag types found,
+  // even if they're not visible. (ref?)
+  if (HasTag && !Ambiguous && (HasFunction || HasNonFunction))
+    Decls[UniqueTagIndex] = Decls[--N];
+
+  Decls.set_size(N);
+
+  if (HasFunction && HasNonFunction)
+    Ambiguous = true;
+
+  if (Ambiguous)
+    setAmbiguous(LookupResult::AmbiguousReference);
+  else if (N > 1)
+    Kind = LookupResult::FoundOverloaded;
+  else
+    Kind = LookupResult::Found;
 }
 
 /// @brief Converts the result of name lookup into a single (possible
@@ -423,197 +236,99 @@ Sema::LookupResult::LookupKind Sema::LookupResult::getKind() const {
 /// (if only a single declaration was found), an
 /// OverloadedFunctionDecl (if an overloaded function was found), or
 /// NULL (if no declaration was found). This conversion must not be
-/// used anywhere where name lookup could result in an ambiguity. 
+/// used anywhere where name lookup could result in an ambiguity.
 ///
 /// The OverloadedFunctionDecl conversion is meant as a stop-gap
 /// solution, since it causes the OverloadedFunctionDecl to be
 /// leaked. FIXME: Eventually, there will be a better way to iterate
 /// over the set of overloaded functions returned by name lookup.
-NamedDecl *Sema::LookupResult::getAsDecl() const {
-  switch (StoredKind) {
-  case SingleDecl:
-    return reinterpret_cast<NamedDecl *>(First);
-
-  case OverloadedDeclFromIdResolver:
-    return MaybeConstructOverloadSet(*Context,
-                         IdentifierResolver::iterator::getFromOpaqueValue(First),
-                         IdentifierResolver::iterator::getFromOpaqueValue(Last));
-
-  case OverloadedDeclFromDeclContext:
-    return MaybeConstructOverloadSet(*Context, 
-                           reinterpret_cast<DeclContext::lookup_iterator>(First),
-                           reinterpret_cast<DeclContext::lookup_iterator>(Last));
-
-  case OverloadedDeclSingleDecl:
-    return reinterpret_cast<OverloadedFunctionDecl*>(First);
-
-  case AmbiguousLookupStoresDecls:
-  case AmbiguousLookupStoresBasePaths:
-    assert(false && 
-           "Name lookup returned an ambiguity that could not be handled");
-    break;
+NamedDecl *Sema::LookupResult::getAsSingleDecl(ASTContext &C) const {
+  size_t size = Decls.size();
+  if (size == 0) return 0;
+  if (size == 1) return *begin();
+
+  if (isAmbiguous()) return 0;
+
+  iterator I = begin(), E = end();
+
+  OverloadedFunctionDecl *Ovl
+    = OverloadedFunctionDecl::Create(C, (*I)->getDeclContext(),
+                                        (*I)->getDeclName());
+  for (; I != E; ++I) {
+    NamedDecl *ND = *I;
+    assert(ND->getUnderlyingDecl() == ND
+           && "decls in lookup result should have redirections stripped");
+    assert(ND->isFunctionOrFunctionTemplate());
+    if (isa<FunctionDecl>(ND))
+      Ovl->addOverload(cast<FunctionDecl>(ND));
+    else
+      Ovl->addOverload(cast<FunctionTemplateDecl>(ND));
+    // FIXME: UnresolvedUsingDecls.
   }
-
-  return 0;
+  
+  return Ovl;
 }
 
-/// @brief Retrieves the BasePaths structure describing an ambiguous
-/// name lookup, or null.
-BasePaths *Sema::LookupResult::getBasePaths() const {
-  if (StoredKind == AmbiguousLookupStoresBasePaths)
-      return reinterpret_cast<BasePaths *>(First);
-  return 0;
+void Sema::LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
+  CXXBasePaths::paths_iterator I, E;
+  DeclContext::lookup_iterator DI, DE;
+  for (I = P.begin(), E = P.end(); I != E; ++I)
+    for (llvm::tie(DI,DE) = I->Decls; DI != DE; ++DI)
+      addDecl(*DI);
 }
 
-Sema::LookupResult::iterator::reference 
-Sema::LookupResult::iterator::operator*() const {
-  switch (Result->StoredKind) {
-  case SingleDecl:
-    return reinterpret_cast<NamedDecl*>(Current);
-
-  case OverloadedDeclSingleDecl:
-    return *reinterpret_cast<NamedDecl**>(Current);
-
-  case OverloadedDeclFromIdResolver:
-    return *IdentifierResolver::iterator::getFromOpaqueValue(Current);
-
-  case AmbiguousLookupStoresBasePaths:
-    if (Result->Last)
-      return *reinterpret_cast<NamedDecl**>(Current);
-
-    // Fall through to handle the DeclContext::lookup_iterator we're
-    // storing.
-
-  case OverloadedDeclFromDeclContext:
-  case AmbiguousLookupStoresDecls:
-    return *reinterpret_cast<DeclContext::lookup_iterator>(Current);
-  }
-
-  return 0;
+void Sema::LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) {
+  Paths = new CXXBasePaths;
+  Paths->swap(P);
+  addDeclsFromBasePaths(*Paths);
+  resolveKind();
+  setAmbiguous(AmbiguousBaseSubobjects);
 }
 
-Sema::LookupResult::iterator& Sema::LookupResult::iterator::operator++() {
-  switch (Result->StoredKind) {
-  case SingleDecl:
-    Current = reinterpret_cast<uintptr_t>((NamedDecl*)0);
-    break;
-
-  case OverloadedDeclSingleDecl: {
-    NamedDecl ** I = reinterpret_cast<NamedDecl**>(Current);
-    ++I;
-    Current = reinterpret_cast<uintptr_t>(I);
-    break;
-  }
-
-  case OverloadedDeclFromIdResolver: {
-    IdentifierResolver::iterator I 
-      = IdentifierResolver::iterator::getFromOpaqueValue(Current);
-    ++I;
-    Current = I.getAsOpaqueValue();
-    break;
-  }
-
-  case AmbiguousLookupStoresBasePaths: 
-    if (Result->Last) {
-      NamedDecl ** I = reinterpret_cast<NamedDecl**>(Current);
-      ++I;
-      Current = reinterpret_cast<uintptr_t>(I);
-      break;
-    }
-    // Fall through to handle the DeclContext::lookup_iterator we're
-    // storing.
-
-  case OverloadedDeclFromDeclContext:
-  case AmbiguousLookupStoresDecls: {
-    DeclContext::lookup_iterator I 
-      = reinterpret_cast<DeclContext::lookup_iterator>(Current);
-    ++I;
-    Current = reinterpret_cast<uintptr_t>(I);
-    break;
-  }
-  }
-
-  return *this;
+void Sema::LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) {
+  Paths = new CXXBasePaths;
+  Paths->swap(P);
+  addDeclsFromBasePaths(*Paths);
+  resolveKind();
+  setAmbiguous(AmbiguousBaseSubobjectTypes);
 }
 
-Sema::LookupResult::iterator Sema::LookupResult::begin() {
-  switch (StoredKind) {
-  case SingleDecl:
-  case OverloadedDeclFromIdResolver:
-  case OverloadedDeclFromDeclContext:
-  case AmbiguousLookupStoresDecls:
-    return iterator(this, First);
-
-  case OverloadedDeclSingleDecl: {
-    OverloadedFunctionDecl * Ovl =
-      reinterpret_cast<OverloadedFunctionDecl*>(First);
-    return iterator(this, 
-                    reinterpret_cast<uintptr_t>(&(*Ovl->function_begin())));
-  }
-
-  case AmbiguousLookupStoresBasePaths:
-    if (Last)
-      return iterator(this, 
-              reinterpret_cast<uintptr_t>(getBasePaths()->found_decls_begin()));
-    else
-      return iterator(this,
-              reinterpret_cast<uintptr_t>(getBasePaths()->front().Decls.first));
+void Sema::LookupResult::print(llvm::raw_ostream &Out) {
+  Out << Decls.size() << " result(s)";
+  if (isAmbiguous()) Out << ", ambiguous";
+  if (Paths) Out << ", base paths present";
+  
+  for (iterator I = begin(), E = end(); I != E; ++I) {
+    Out << "\n";
+    (*I)->print(Out, 2);
   }
-
-  // Required to suppress GCC warning.
-  return iterator();
 }
 
-Sema::LookupResult::iterator Sema::LookupResult::end() {
-  switch (StoredKind) {
-  case SingleDecl:
-  case OverloadedDeclFromIdResolver:
-  case OverloadedDeclFromDeclContext:
-  case AmbiguousLookupStoresDecls:
-    return iterator(this, Last);
-
-  case OverloadedDeclSingleDecl: {
-    OverloadedFunctionDecl * Ovl =
-      reinterpret_cast<OverloadedFunctionDecl*>(First);
-    return iterator(this, 
-                    reinterpret_cast<uintptr_t>(&(*Ovl->function_end())));
-  }
-
-  case AmbiguousLookupStoresBasePaths:
-    if (Last)
-      return iterator(this, 
-               reinterpret_cast<uintptr_t>(getBasePaths()->found_decls_end()));
-    else
-      return iterator(this, reinterpret_cast<uintptr_t>(
-                                     getBasePaths()->front().Decls.second));
-  }
+// Adds all qualifying matches for a name within a decl context to the
+// given lookup result.  Returns true if any matches were found.
+static bool LookupDirect(Sema::LookupResult &R, DeclContext *DC,
+                         DeclarationName Name,
+                         Sema::LookupNameKind NameKind,
+                         unsigned IDNS) {
+  bool Found = false;
 
-  // Required to suppress GCC warning.
-  return iterator();
-}
+  DeclContext::lookup_iterator I, E;
+  for (llvm::tie(I, E) = DC->lookup(Name); I != E; ++I)
+    if (Sema::isAcceptableLookupResult(*I, NameKind, IDNS))
+      R.addDecl(*I), Found = true;
 
-void Sema::LookupResult::Destroy() {
-  if (BasePaths *Paths = getBasePaths())
-    delete Paths;
-  else if (getKind() == AmbiguousReference)
-    delete[] reinterpret_cast<NamedDecl **>(First);
+  return Found;
 }
 
-static void
-CppNamespaceLookup(ASTContext &Context, DeclContext *NS,
+static bool
+CppNamespaceLookup(Sema::LookupResult &R, ASTContext &Context, DeclContext *NS,
                    DeclarationName Name, Sema::LookupNameKind NameKind,
-                   unsigned IDNS, LookupResultsTy &Results,
-                   UsingDirectivesTy *UDirs = 0) {
+                   unsigned IDNS, UsingDirectivesTy *UDirs = 0) {
 
   assert(NS && NS->isFileContext() && "CppNamespaceLookup() requires namespace!");
 
   // Perform qualified name lookup into the LookupCtx.
-  DeclContext::lookup_iterator I, E;
-  for (llvm::tie(I, E) = NS->lookup(Name); I != E; ++I)
-    if (Sema::isAcceptableLookupResult(*I, NameKind, IDNS)) {
-      Results.push_back(Sema::LookupResult::CreateLookupResult(Context, I, E));
-      break;
-    }
+  bool Found = LookupDirect(R, NS, Name, NameKind, IDNS);
 
   if (UDirs) {
     // For each UsingDirectiveDecl, which common ancestor is equal
@@ -622,11 +337,15 @@ CppNamespaceLookup(ASTContext &Context, DeclContext *NS,
     llvm::tie(UI, UEnd) =
       std::equal_range(UDirs->begin(), UDirs->end(), NS,
                        UsingDirAncestorCompare());
- 
+
     for (; UI != UEnd; ++UI)
-      CppNamespaceLookup(Context, (*UI)->getNominatedNamespace(),
-                         Name, NameKind, IDNS, Results);
+      if (LookupDirect(R, (*UI)->getNominatedNamespace(), Name, NameKind, IDNS))
+        Found = true;
   }
+
+  R.resolveKind();
+
+  return Found;
 }
 
 static bool isNamespaceOrTranslationUnitScope(Scope *S) {
@@ -635,16 +354,31 @@ static bool isNamespaceOrTranslationUnitScope(Scope *S) {
   return false;
 }
 
-std::pair<bool, Sema::LookupResult>
-Sema::CppLookupName(Scope *S, DeclarationName Name,
+// Find the next outer declaration context corresponding to this scope.
+static DeclContext *findOuterContext(Scope *S) {
+  for (S = S->getParent(); S; S = S->getParent())
+    if (S->getEntity())
+      return static_cast<DeclContext *>(S->getEntity())->getPrimaryContext();
+  
+  return 0;
+}
+
+bool
+Sema::CppLookupName(LookupResult &R, Scope *S, DeclarationName Name,
                     LookupNameKind NameKind, bool RedeclarationOnly) {
   assert(getLangOptions().CPlusPlus &&
          "Can perform only C++ lookup");
-  unsigned IDNS 
+  unsigned IDNS
     = getIdentifierNamespacesFromLookupNameKind(NameKind, /*CPlusPlus*/ true);
+
+  // If we're testing for redeclarations, also look in the friend namespaces.
+  if (RedeclarationOnly) {
+    if (IDNS & Decl::IDNS_Tag) IDNS |= Decl::IDNS_TagFriend;
+    if (IDNS & Decl::IDNS_Ordinary) IDNS |= Decl::IDNS_OrdinaryFriend;
+  }
+
   Scope *Initial = S;
-  DeclContext *OutOfLineCtx = 0;
-  IdentifierResolver::iterator 
+  IdentifierResolver::iterator
     I = IdResolver.begin(Name),
     IEnd = IdResolver.end();
 
@@ -653,8 +387,8 @@ Sema::CppLookupName(Scope *S, DeclarationName Name,
   // ...During unqualified name lookup (3.4.1), the names appear as if
   // they were declared in the nearest enclosing namespace which contains
   // both the using-directive and the nominated namespace.
-  // [Note: in this context, “contains” means “contains directly or
-  // indirectly”. 
+  // [Note: in this context, "contains" means "contains directly or
+  // indirectly".
   //
   // For example:
   // namespace A { int i; }
@@ -668,47 +402,33 @@ Sema::CppLookupName(Scope *S, DeclarationName Name,
   //
   for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
     // Check whether the IdResolver has anything in this scope.
+    bool Found = false;
     for (; I != IEnd && S->isDeclScope(DeclPtrTy::make(*I)); ++I) {
       if (isAcceptableLookupResult(*I, NameKind, IDNS)) {
-        // We found something.  Look for anything else in our scope
-        // with this same name and in an acceptable identifier
-        // namespace, so that we can construct an overload set if we
-        // need to.
-        IdentifierResolver::iterator LastI = I;
-        for (++LastI; LastI != IEnd; ++LastI) {
-          if (!S->isDeclScope(DeclPtrTy::make(*LastI)))
-            break;
-        }
-        LookupResult Result =
-          LookupResult::CreateLookupResult(Context, I, LastI);
-        return std::make_pair(true, Result);
+        Found = true;
+        R.addDecl(*I);
       }
     }
+    if (Found) {
+      R.resolveKind();
+      return true;
+    }
+
     if (DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity())) {
-      LookupResult R;
-      // Perform member lookup into struct.
-      // FIXME: In some cases, we know that every name that could be found by
-      // this qualified name lookup will also be on the identifier chain. For
-      // example, inside a class without any base classes, we never need to
-      // perform qualified lookup because all of the members are on top of the
-      // identifier chain.
-      if (isa<RecordDecl>(Ctx)) {
-        R = LookupQualifiedName(Ctx, Name, NameKind, RedeclarationOnly);
-        if (R)
-          return std::make_pair(true, R);
-      }
-      if (Ctx->getParent() != Ctx->getLexicalParent() 
-          || isa<CXXMethodDecl>(Ctx)) {
-        // It is out of line defined C++ method or struct, we continue
-        // doing name lookup in parent context. Once we will find namespace
-        // or translation-unit we save it for possible checking
-        // using-directives later.
-        for (OutOfLineCtx = Ctx; OutOfLineCtx && !OutOfLineCtx->isFileContext();
-             OutOfLineCtx = OutOfLineCtx->getParent()) {
-          R = LookupQualifiedName(OutOfLineCtx, Name, NameKind, RedeclarationOnly);
-          if (R)
-            return std::make_pair(true, R);
-        }
+      DeclContext *OuterCtx = findOuterContext(S);
+      for (; Ctx && Ctx->getPrimaryContext() != OuterCtx; 
+           Ctx = Ctx->getLookupParent()) {
+        if (Ctx->isFunctionOrMethod())
+          continue;
+        
+        // Perform qualified name lookup into this context.
+        // FIXME: In some cases, we know that every name that could be found by
+        // this qualified name lookup will also be on the identifier chain. For
+        // example, inside a class without any base classes, we never need to
+        // perform qualified lookup because all of the members are on top of the
+        // identifier chain.
+        if (LookupQualifiedName(R, Ctx, Name, NameKind, RedeclarationOnly))
+          return true;
       }
     }
   }
@@ -731,71 +451,41 @@ Sema::CppLookupName(Scope *S, DeclarationName Name,
   // that aren't strictly lexical, and therefore we walk through the
   // context as well as walking through the scopes.
 
-  LookupResultsTy LookupResults;
-  assert((!OutOfLineCtx || OutOfLineCtx->isFileContext()) &&
-         "We should have been looking only at file context here already.");
-  bool LookedInCtx = false;
-  LookupResult Result;
-  while (OutOfLineCtx &&
-         OutOfLineCtx != S->getEntity() &&
-         OutOfLineCtx->isNamespace()) {
-    LookedInCtx = true;
-
-    // Look into context considering using-directives.
-    CppNamespaceLookup(Context, OutOfLineCtx, Name, NameKind, IDNS,
-                       LookupResults, &UDirs);
-
-    if ((Result = MergeLookupResults(Context, LookupResults)) ||
-        (RedeclarationOnly && !OutOfLineCtx->isTransparentContext()))
-      return std::make_pair(true, Result);
-
-    OutOfLineCtx = OutOfLineCtx->getParent();
-  }
-
   for (; S; S = S->getParent()) {
     DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity());
+    if (Ctx->isTransparentContext())
+      continue;
+
     assert(Ctx && Ctx->isFileContext() &&
            "We should have been looking only at file context here already.");
 
     // Check whether the IdResolver has anything in this scope.
+    bool Found = false;
     for (; I != IEnd && S->isDeclScope(DeclPtrTy::make(*I)); ++I) {
       if (isAcceptableLookupResult(*I, NameKind, IDNS)) {
         // We found something.  Look for anything else in our scope
         // with this same name and in an acceptable identifier
         // namespace, so that we can construct an overload set if we
         // need to.
-        IdentifierResolver::iterator LastI = I;
-        for (++LastI; LastI != IEnd; ++LastI) {
-          if (!S->isDeclScope(DeclPtrTy::make(*LastI)))
-            break;
-        }
-        
-        // We store name lookup result, and continue trying to look into
-        // associated context, and maybe namespaces nominated by
-        // using-directives.
-        LookupResults.push_back(
-          LookupResult::CreateLookupResult(Context, I, LastI));
-        break;
+        Found = true;
+        R.addDecl(*I);
       }
     }
 
-    LookedInCtx = true;
     // Look into context considering using-directives.
-    CppNamespaceLookup(Context, Ctx, Name, NameKind, IDNS,
-                       LookupResults, &UDirs);
+    if (CppNamespaceLookup(R, Context, Ctx, Name, NameKind, IDNS, &UDirs))
+      Found = true;
 
-    if ((Result = MergeLookupResults(Context, LookupResults)) ||
-        (RedeclarationOnly && !Ctx->isTransparentContext()))
-      return std::make_pair(true, Result);
-  }
+    if (Found) {
+      R.resolveKind();
+      return true;
+    }
 
-  if (!(LookedInCtx || LookupResults.empty())) {
-    // We didn't Performed lookup in Scope entity, so we return
-    // result form IdentifierResolver.
-    assert((LookupResults.size() == 1) && "Wrong size!");
-    return std::make_pair(true, LookupResults.front());
+    if (RedeclarationOnly && !Ctx->isTransparentContext())
+      return false;
   }
-  return std::make_pair(false, LookupResult());
+
+  return !R.empty();
 }
 
 /// @brief Perform unqualified name lookup starting from a given
@@ -823,17 +513,16 @@ Sema::CppLookupName(Scope *S, DeclarationName Name,
 /// @param Name     The name of the entity that we are searching for.
 ///
 /// @param Loc      If provided, the source location where we're performing
-/// name lookup. At present, this is only used to produce diagnostics when 
+/// name lookup. At present, this is only used to produce diagnostics when
 /// C library functions (like "malloc") are implicitly declared.
 ///
 /// @returns The result of name lookup, which includes zero or more
 /// declarations and possibly additional information used to diagnose
 /// ambiguities.
-Sema::LookupResult 
-Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
-                 bool RedeclarationOnly, bool AllowBuiltinCreation,
-                 SourceLocation Loc) {
-  if (!Name) return LookupResult::CreateLookupResult(Context, 0);
+bool Sema::LookupName(LookupResult &R, Scope *S, DeclarationName Name,
+                      LookupNameKind NameKind, bool RedeclarationOnly,
+                      bool AllowBuiltinCreation, SourceLocation Loc) {
+  if (!Name) return false;
 
   if (!getLangOptions().CPlusPlus) {
     // Unqualified name lookup in C/Objective-C is purely lexical, so
@@ -861,7 +550,7 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
     case Sema::LookupRedeclarationWithLinkage:
       // Find the nearest non-transparent declaration scope.
       while (!(S->getFlags() & Scope::DeclScope) ||
-             (S->getEntity() && 
+             (S->getEntity() &&
               static_cast<DeclContext *>(S->getEntity())
                 ->isTransparentContext()))
         S = S->getParent();
@@ -875,7 +564,7 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
     case Sema::LookupObjCImplementationName:
       IDNS = Decl::IDNS_ObjCImplementation;
       break;
-      
+
     case Sema::LookupObjCCategoryImplName:
       IDNS = Decl::IDNS_ObjCCategoryImpl;
       break;
@@ -888,7 +577,7 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
     bool LeftStartingScope = false;
 
     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
-                                   IEnd = IdResolver.end(); 
+                                   IEnd = IdResolver.end();
          I != IEnd; ++I)
       if ((*I)->isInIdentifierNamespace(IDNS)) {
         if (NameKind == LookupRedeclarationWithLinkage) {
@@ -903,6 +592,8 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
             continue;
         }
 
+        R.addDecl(*I);
+
         if ((*I)->getAttr<OverloadableAttr>()) {
           // If this declaration has the "overloadable" attribute, we
           // might have a set of overloaded functions.
@@ -918,26 +609,24 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
           for (++LastI; LastI != IEnd; ++LastI) {
             if (!S->isDeclScope(DeclPtrTy::make(*LastI)))
               break;
+            R.addDecl(*LastI);
           }
-
-          return LookupResult::CreateLookupResult(Context, I, LastI);
         }
 
-        // We have a single lookup result.
-        return LookupResult::CreateLookupResult(Context, *I);
+        R.resolveKind();
+
+        return true;
       }
   } else {
     // Perform C++ unqualified name lookup.
-    std::pair<bool, LookupResult> MaybeResult =
-      CppLookupName(S, Name, NameKind, RedeclarationOnly);
-    if (MaybeResult.first)
-      return MaybeResult.second;
+    if (CppLookupName(R, S, Name, NameKind, RedeclarationOnly))
+      return true;
   }
 
   // If we didn't find a use of this identifier, and if the identifier
   // corresponds to a compiler builtin, create the decl object for the builtin
   // now, injecting it into translation unit scope, and return it.
-  if (NameKind == LookupOrdinaryName || 
+  if (NameKind == LookupOrdinaryName ||
       NameKind == LookupRedeclarationWithLinkage) {
     IdentifierInfo *II = Name.getAsIdentifierInfo();
     if (II && AllowBuiltinCreation) {
@@ -945,17 +634,132 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
       if (unsigned BuiltinID = II->getBuiltinID()) {
         // In C++, we don't have any predefined library functions like
         // 'malloc'. Instead, we'll just error.
-        if (getLangOptions().CPlusPlus && 
+        if (getLangOptions().CPlusPlus &&
             Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
-          return LookupResult::CreateLookupResult(Context, 0);
+          return false;
+
+        NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
+                                           S, RedeclarationOnly, Loc);
+        if (D) R.addDecl(D);
+        return (D != NULL);
+      }
+    }
+  }
+  return false;
+}
+
+/// @brief Perform qualified name lookup in the namespaces nominated by
+/// using directives by the given context.
+///
+/// C++98 [namespace.qual]p2:
+///   Given X::m (where X is a user-declared namespace), or given ::m
+///   (where X is the global namespace), let S be the set of all
+///   declarations of m in X and in the transitive closure of all
+///   namespaces nominated by using-directives in X and its used
+///   namespaces, except that using-directives are ignored in any
+///   namespace, including X, directly containing one or more
+///   declarations of m. No namespace is searched more than once in
+///   the lookup of a name. If S is the empty set, the program is
+///   ill-formed. Otherwise, if S has exactly one member, or if the
+///   context of the reference is a using-declaration
+///   (namespace.udecl), S is the required set of declarations of
+///   m. Otherwise if the use of m is not one that allows a unique
+///   declaration to be chosen from S, the program is ill-formed.
+/// C++98 [namespace.qual]p5:
+///   During the lookup of a qualified namespace member name, if the
+///   lookup finds more than one declaration of the member, and if one
+///   declaration introduces a class name or enumeration name and the
+///   other declarations either introduce the same object, the same
+///   enumerator or a set of functions, the non-type name hides the
+///   class or enumeration name if and only if the declarations are
+///   from the same namespace; otherwise (the declarations are from
+///   different namespaces), the program is ill-formed.
+static bool LookupQualifiedNameInUsingDirectives(Sema::LookupResult &R,
+                                                 DeclContext *StartDC,
+                                                 DeclarationName Name,
+                                                 Sema::LookupNameKind NameKind,
+                                                 unsigned IDNS) {
+  assert(StartDC->isFileContext() && "start context is not a file context");
+
+  DeclContext::udir_iterator I = StartDC->using_directives_begin();
+  DeclContext::udir_iterator E = StartDC->using_directives_end();
+
+  if (I == E) return false;
+
+  // We have at least added all these contexts to the queue.
+  llvm::DenseSet<DeclContext*> Visited;
+  Visited.insert(StartDC);
+
+  // We have not yet looked into these namespaces, much less added
+  // their "using-children" to the queue.
+  llvm::SmallVector<NamespaceDecl*, 8> Queue;
+
+  // We have already looked into the initial namespace; seed the queue
+  // with its using-children.
+  for (; I != E; ++I) {
+    NamespaceDecl *ND = (*I)->getNominatedNamespace();
+    if (Visited.insert(ND).second)
+      Queue.push_back(ND);
+  }
+
+  // The easiest way to implement the restriction in [namespace.qual]p5
+  // is to check whether any of the individual results found a tag
+  // and, if so, to declare an ambiguity if the final result is not
+  // a tag.
+  bool FoundTag = false;
+  bool FoundNonTag = false;
+
+  Sema::LookupResult LocalR;
+
+  bool Found = false;
+  while (!Queue.empty()) {
+    NamespaceDecl *ND = Queue.back();
+    Queue.pop_back();
+
+    // We go through some convolutions here to avoid copying results
+    // between LookupResults.
+    bool UseLocal = !R.empty();
+    Sema::LookupResult &DirectR = UseLocal ? LocalR : R;
+    bool FoundDirect = LookupDirect(DirectR, ND, Name, NameKind, IDNS);
+
+    if (FoundDirect) {
+      // First do any local hiding.
+      DirectR.resolveKind();
+
+      // If the local result is a tag, remember that.
+      if (DirectR.isSingleTagDecl())
+        FoundTag = true;
+      else
+        FoundNonTag = true;
 
-        return LookupResult::CreateLookupResult(Context,
-                            LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
-                                                S, RedeclarationOnly, Loc));
+      // Append the local results to the total results if necessary.
+      if (UseLocal) {
+        R.addAllDecls(LocalR);
+        LocalR.clear();
       }
     }
+
+    // If we find names in this namespace, ignore its using directives.
+    if (FoundDirect) {
+      Found = true;
+      continue;
+    }
+
+    for (llvm::tie(I,E) = ND->getUsingDirectives(); I != E; ++I) {
+      NamespaceDecl *Nom = (*I)->getNominatedNamespace();
+      if (Visited.insert(Nom).second)
+        Queue.push_back(Nom);
+    }
   }
-  return LookupResult::CreateLookupResult(Context, 0);
+
+  if (Found) {
+    if (FoundTag && FoundNonTag)
+      R.setAmbiguousQualifiedTagHiding();
+    else
+      R.resolveKind();
+  }
+
+  return Found;
 }
 
 /// @brief Perform qualified name lookup into a given context.
@@ -988,40 +792,91 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
 /// @returns The result of name lookup, which includes zero or more
 /// declarations and possibly additional information used to diagnose
 /// ambiguities.
-Sema::LookupResult
-Sema::LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
-                          LookupNameKind NameKind, bool RedeclarationOnly) {
+bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
+                               DeclarationName Name, LookupNameKind NameKind,
+                               bool RedeclarationOnly) {
   assert(LookupCtx && "Sema::LookupQualifiedName requires a lookup context");
-  
-  if (!Name) return LookupResult::CreateLookupResult(Context, 0);
+
+  if (!Name)
+    return false;
 
   // If we're performing qualified name lookup (e.g., lookup into a
   // struct), find fields as part of ordinary name lookup.
   unsigned IDNS
-    = getIdentifierNamespacesFromLookupNameKind(NameKind, 
+    = getIdentifierNamespacesFromLookupNameKind(NameKind,
                                                 getLangOptions().CPlusPlus);
   if (NameKind == LookupOrdinaryName)
     IDNS |= Decl::IDNS_Member;
 
+  // Make sure that the declaration context is complete.
+  assert((!isa<TagDecl>(LookupCtx) ||
+          LookupCtx->isDependentContext() ||
+          cast<TagDecl>(LookupCtx)->isDefinition() ||
+          Context.getTypeDeclType(cast<TagDecl>(LookupCtx))->getAs<TagType>()
+            ->isBeingDefined()) &&
+         "Declaration context must already be complete!");
+
   // Perform qualified name lookup into the LookupCtx.
-  DeclContext::lookup_iterator I, E;
-  for (llvm::tie(I, E) = LookupCtx->lookup(Name); I != E; ++I)
-    if (isAcceptableLookupResult(*I, NameKind, IDNS))
-      return LookupResult::CreateLookupResult(Context, I, E);
+  if (LookupDirect(R, LookupCtx, Name, NameKind, IDNS)) {
+    R.resolveKind();
+    return true;
+  }
+
+  // Don't descend into implied contexts for redeclarations.
+  // C++98 [namespace.qual]p6:
+  //   In a declaration for a namespace member in which the
+  //   declarator-id is a qualified-id, given that the qualified-id
+  //   for the namespace member has the form
+  //     nested-name-specifier unqualified-id
+  //   the unqualified-id shall name a member of the namespace
+  //   designated by the nested-name-specifier.
+  // See also [class.mfct]p5 and [class.static.data]p2.
+  if (RedeclarationOnly)
+    return false;
 
-  // If this isn't a C++ class or we aren't allowed to look into base
+  // If this is a namespace, look it up in 
+  if (LookupCtx->isFileContext())
+    return LookupQualifiedNameInUsingDirectives(R, LookupCtx, Name, NameKind,
+                                                IDNS);
+
+  // If this isn't a C++ class, we aren't allowed to look into base
   // classes, we're done.
-  if (RedeclarationOnly || !isa<CXXRecordDecl>(LookupCtx))
-    return LookupResult::CreateLookupResult(Context, 0);
+  if (!isa<CXXRecordDecl>(LookupCtx))
+    return false;
 
   // Perform lookup into our base classes.
-  BasePaths Paths;
-  Paths.setOrigin(Context.getTypeDeclType(cast<RecordDecl>(LookupCtx)));
+  CXXRecordDecl *LookupRec = cast<CXXRecordDecl>(LookupCtx);
+  CXXBasePaths Paths;
+  Paths.setOrigin(LookupRec);
 
   // Look for this member in our base classes
-  if (!LookupInBases(cast<CXXRecordDecl>(LookupCtx), 
-                     MemberLookupCriteria(Name, NameKind, IDNS), Paths))
-    return LookupResult::CreateLookupResult(Context, 0);
+  CXXRecordDecl::BaseMatchesCallback *BaseCallback = 0;
+  switch (NameKind) {
+    case LookupOrdinaryName:
+    case LookupMemberName:
+    case LookupRedeclarationWithLinkage:
+      BaseCallback = &CXXRecordDecl::FindOrdinaryMember;
+      break;
+      
+    case LookupTagName:
+      BaseCallback = &CXXRecordDecl::FindTagMember;
+      break;
+      
+    case LookupOperatorName:
+    case LookupNamespaceName:
+    case LookupObjCProtocolName:
+    case LookupObjCImplementationName:
+    case LookupObjCCategoryImplName:
+      // These lookups will never find a member in a C++ class (or base class).
+      return false;
+      
+    case LookupNestedNameSpecifierName:
+      BaseCallback = &CXXRecordDecl::FindNestedNameSpecifierMember;
+      break;
+  }
+  
+  if (!LookupRec->lookupInBases(BaseCallback, Name.getAsOpaquePtr(), Paths))
+    return false;
 
   // C++ [class.member.lookup]p2:
   //   [...] If the resulting set of declarations are not all from
@@ -1032,29 +887,28 @@ Sema::LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
   // FIXME: support using declarations!
   QualType SubobjectType;
   int SubobjectNumber = 0;
-  for (BasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
+  for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
        Path != PathEnd; ++Path) {
-    const BasePathElement &PathElement = Path->back();
+    const CXXBasePathElement &PathElement = Path->back();
 
     // Determine whether we're looking at a distinct sub-object or not.
     if (SubobjectType.isNull()) {
-      // This is the first subobject we've looked at. Record it's type.
+      // This is the first subobject we've looked at. Record its type.
       SubobjectType = Context.getCanonicalType(PathElement.Base->getType());
       SubobjectNumber = PathElement.SubobjectNumber;
-    } else if (SubobjectType 
+    } else if (SubobjectType
                  != Context.getCanonicalType(PathElement.Base->getType())) {
       // We found members of the given name in two subobjects of
       // different types. This lookup is ambiguous.
-      BasePaths *PathsOnHeap = new BasePaths;
-      PathsOnHeap->swap(Paths);
-      return LookupResult::CreateLookupResult(Context, PathsOnHeap, true);
+      R.setAmbiguousBaseSubobjectTypes(Paths);
+      return true;
     } else if (SubobjectNumber != PathElement.SubobjectNumber) {
       // We have a different subobject of the same type.
 
       // C++ [class.member.lookup]p5:
       //   A static member, a nested type or an enumerator defined in
       //   a base class T can unambiguously be found even if an object
-      //   has more than one base class subobject of type T. 
+      //   has more than one base class subobject of type T.
       Decl *FirstDecl = *Path->Decls.first;
       if (isa<VarDecl>(FirstDecl) ||
           isa<TypeDecl>(FirstDecl) ||
@@ -1083,21 +937,18 @@ Sema::LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
 
       // We have found a nonstatic member name in multiple, distinct
       // subobjects. Name lookup is ambiguous.
-      BasePaths *PathsOnHeap = new BasePaths;
-      PathsOnHeap->swap(Paths);
-      return LookupResult::CreateLookupResult(Context, PathsOnHeap, false);
+      R.setAmbiguousBaseSubobjects(Paths);
+      return true;
     }
   }
 
   // Lookup in a base class succeeded; return these results.
 
-  // If we found a function declaration, return an overload set.
-  if ((*Paths.front().Decls.first)->isFunctionOrFunctionTemplate())
-    return LookupResult::CreateLookupResult(Context, 
-                        Paths.front().Decls.first, Paths.front().Decls.second);
-
-  // We found a non-function declaration; return a single declaration.
-  return LookupResult::CreateLookupResult(Context, *Paths.front().Decls.first);
+  DeclContext::lookup_iterator I, E;
+  for (llvm::tie(I,E) = Paths.front().Decls; I != E; ++I)
+    R.addDecl(*I);
+  R.resolveKind();
+  return true;
 }
 
 /// @brief Performs name lookup for a name that was parsed in the
@@ -1111,59 +962,50 @@ Sema::LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
 ///
 /// @param S        The scope from which unqualified name lookup will
 /// begin.
-/// 
-/// @param SS       An optional C++ scope-specified, e.g., "::N::M".
+///
+/// @param SS       An optional C++ scope-specifier, e.g., "::N::M".
 ///
 /// @param Name     The name of the entity that name lookup will
 /// search for.
 ///
 /// @param Loc      If provided, the source location where we're performing
-/// name lookup. At present, this is only used to produce diagnostics when 
+/// name lookup. At present, this is only used to produce diagnostics when
 /// C library functions (like "malloc") are implicitly declared.
 ///
-/// @returns The result of qualified or unqualified name lookup.
-Sema::LookupResult
-Sema::LookupParsedName(Scope *S, const CXXScopeSpec *SS, 
-                       DeclarationName Name, LookupNameKind NameKind,
-                       bool RedeclarationOnly, bool AllowBuiltinCreation,
-                       SourceLocation Loc) {
-  if (SS && (SS->isSet() || SS->isInvalid())) {
-    // If the scope specifier is invalid, don't even look for
+/// @param EnteringContext Indicates whether we are going to enter the
+/// context of the scope-specifier SS (if present).
+///
+/// @returns True if any decls were found (but possibly ambiguous)
+bool Sema::LookupParsedName(LookupResult &R, Scope *S, const CXXScopeSpec *SS,
+                            DeclarationName Name, LookupNameKind NameKind,
+                            bool RedeclarationOnly, bool AllowBuiltinCreation,
+                            SourceLocation Loc,
+                            bool EnteringContext) {
+  if (SS && SS->isInvalid()) {
+    // When the scope specifier is invalid, don't even look for
     // anything.
-    if (SS->isInvalid())
-      return LookupResult::CreateLookupResult(Context, 0);
-
-    assert(!isUnknownSpecialization(*SS) && "Can't lookup dependent types");
-
-    if (isDependentScopeSpecifier(*SS)) {
-      // Determine whether we are looking into the current
-      // instantiation. 
-      NestedNameSpecifier *NNS 
-        = static_cast<NestedNameSpecifier *>(SS->getScopeRep());
-      CXXRecordDecl *Current = getCurrentInstantiationOf(NNS);
-      assert(Current && "Bad dependent scope specifier");
-      
-      // We nested name specifier refers to the current instantiation,
-      // so now we will look for a member of the current instantiation
-      // (C++0x [temp.dep.type]).
-      unsigned IDNS = getIdentifierNamespacesFromLookupNameKind(NameKind, true);
-      DeclContext::lookup_iterator I, E;
-      for (llvm::tie(I, E) = Current->lookup(Name); I != E; ++I)
-        if (isAcceptableLookupResult(*I, NameKind, IDNS))
-          return LookupResult::CreateLookupResult(Context, I, E);
-    }
+    return false;
+  }
 
-    if (RequireCompleteDeclContext(*SS))
-      return LookupResult::CreateLookupResult(Context, 0);
+  if (SS && SS->isSet()) {
+    if (DeclContext *DC = computeDeclContext(*SS, EnteringContext)) {
+      // We have resolved the scope specifier to a particular declaration
+      // contex, and will perform name lookup in that context.
+      if (!DC->isDependentContext() && RequireCompleteDeclContext(*SS))
+        return false;
 
-    return LookupQualifiedName(computeDeclContext(*SS),
-                               Name, NameKind, RedeclarationOnly);
+      return LookupQualifiedName(R, DC, Name, NameKind, RedeclarationOnly);
+    }
+
+    // We could not resolve the scope specified to a specific declaration
+    // context, which means that SS refers to an unknown specialization.
+    // Name lookup can't find anything in this case.
+    return false;
   }
 
-  LookupResult result(LookupName(S, Name, NameKind, RedeclarationOnly, 
-                    AllowBuiltinCreation, Loc));
-  
-  return(result);
+  // Perform unqualified name lookup starting in the given scope.
+  return LookupName(R, S, Name, NameKind, RedeclarationOnly,
+                    AllowBuiltinCreation, Loc);
 }
 
 
@@ -1171,7 +1013,7 @@ Sema::LookupParsedName(Scope *S, const CXXScopeSpec *SS,
 /// from name lookup.
 ///
 /// @param Result       The ambiguous name lookup result.
-/// 
+///
 /// @param Name         The name of the entity that name lookup was
 /// searching for.
 ///
@@ -1184,79 +1026,164 @@ Sema::LookupParsedName(Scope *S, const CXXScopeSpec *SS,
 ///
 /// @returns true
 bool Sema::DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
-                                   SourceLocation NameLoc, 
+                                   SourceLocation NameLoc,
                                    SourceRange LookupRange) {
   assert(Result.isAmbiguous() && "Lookup result must be ambiguous");
 
-  if (BasePaths *Paths = Result.getBasePaths()) {
-    if (Result.getKind() == LookupResult::AmbiguousBaseSubobjects) {
-      QualType SubobjectType = Paths->front().back().Base->getType();
-      Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
-        << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
-        << LookupRange;
-
-      DeclContext::lookup_iterator Found = Paths->front().Decls.first;
-      while (isa<CXXMethodDecl>(*Found) && 
-             cast<CXXMethodDecl>(*Found)->isStatic())
-        ++Found;
-
-      Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
-
-      Result.Destroy();
-      return true;
-    } 
-
-    assert(Result.getKind() == LookupResult::AmbiguousBaseSubobjectTypes &&
-           "Unhandled form of name lookup ambiguity");
+  switch (Result.getAmbiguityKind()) {
+  case LookupResult::AmbiguousBaseSubobjects: {
+    CXXBasePaths *Paths = Result.getBasePaths();
+    QualType SubobjectType = Paths->front().back().Base->getType();
+    Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
+      << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
+      << LookupRange;
+    
+    DeclContext::lookup_iterator Found = Paths->front().Decls.first;
+    while (isa<CXXMethodDecl>(*Found) &&
+           cast<CXXMethodDecl>(*Found)->isStatic())
+      ++Found;
+    
+    Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
+    
+    return true;
+  }
 
+  case LookupResult::AmbiguousBaseSubobjectTypes: {
     Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types)
       << Name << LookupRange;
-
+    
+    CXXBasePaths *Paths = Result.getBasePaths();
     std::set<Decl *> DeclsPrinted;
-    for (BasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end();
+    for (CXXBasePaths::paths_iterator Path = Paths->begin(),
+                                      PathEnd = Paths->end();
          Path != PathEnd; ++Path) {
       Decl *D = *Path->Decls.first;
       if (DeclsPrinted.insert(D).second)
         Diag(D->getLocation(), diag::note_ambiguous_member_found);
     }
 
-    Result.Destroy();
     return true;
-  } else if (Result.getKind() == LookupResult::AmbiguousReference) {
-    Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
+  }
 
-    NamedDecl **DI = reinterpret_cast<NamedDecl **>(Result.First),
-            **DEnd = reinterpret_cast<NamedDecl **>(Result.Last);
+  case LookupResult::AmbiguousTagHiding: {
+    Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;
 
-    for (; DI != DEnd; ++DI)
-      Diag((*DI)->getLocation(), diag::note_ambiguous_candidate) << *DI;
+    llvm::SmallPtrSet<NamedDecl*,8> TagDecls;
+
+    LookupResult::iterator DI, DE = Result.end();
+    for (DI = Result.begin(); DI != DE; ++DI)
+      if (TagDecl *TD = dyn_cast<TagDecl>(*DI)) {
+        TagDecls.insert(TD);
+        Diag(TD->getLocation(), diag::note_hidden_tag);
+      }
+
+    for (DI = Result.begin(); DI != DE; ++DI)
+      if (!isa<TagDecl>(*DI))
+        Diag((*DI)->getLocation(), diag::note_hiding_object);
+
+    // For recovery purposes, go ahead and implement the hiding.
+    Result.hideDecls(TagDecls);
 
-    Result.Destroy();
     return true;
   }
 
-  assert(false && "Unhandled form of name lookup ambiguity");
+  case LookupResult::AmbiguousReference: {
+    Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
+  
+    LookupResult::iterator DI = Result.begin(), DE = Result.end();
+    for (; DI != DE; ++DI)
+      Diag((*DI)->getLocation(), diag::note_ambiguous_candidate) << *DI;
+
+    return true;
+  }
+  }
 
-  // We can't reach here.
+  llvm::llvm_unreachable("unknown ambiguity kind");
   return true;
 }
 
+static void
+addAssociatedClassesAndNamespaces(QualType T,
+                                  ASTContext &Context,
+                          Sema::AssociatedNamespaceSet &AssociatedNamespaces,
+                                  Sema::AssociatedClassSet &AssociatedClasses);
+
+static void CollectNamespace(Sema::AssociatedNamespaceSet &Namespaces,
+                             DeclContext *Ctx) {
+  if (Ctx->isFileContext())
+    Namespaces.insert(Ctx);
+}
+
+// \brief Add the associated classes and namespaces for argument-dependent
+// lookup that involves a template argument (C++ [basic.lookup.koenig]p2).
+static void
+addAssociatedClassesAndNamespaces(const TemplateArgument &Arg,
+                                  ASTContext &Context,
+                           Sema::AssociatedNamespaceSet &AssociatedNamespaces,
+                                  Sema::AssociatedClassSet &AssociatedClasses) {
+  // C++ [basic.lookup.koenig]p2, last bullet:
+  //   -- [...] ;
+  switch (Arg.getKind()) {
+    case TemplateArgument::Null:
+      break;
+
+    case TemplateArgument::Type:
+      // [...] the namespaces and classes associated with the types of the
+      // template arguments provided for template type parameters (excluding
+      // template template parameters)
+      addAssociatedClassesAndNamespaces(Arg.getAsType(), Context,
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
+      break;
+
+    case TemplateArgument::Declaration:
+      // [...] the namespaces in which any template template arguments are
+      // defined; and the classes in which any member templates used as
+      // template template arguments are defined.
+      if (ClassTemplateDecl *ClassTemplate
+            = dyn_cast<ClassTemplateDecl>(Arg.getAsDecl())) {
+        DeclContext *Ctx = ClassTemplate->getDeclContext();
+        if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
+          AssociatedClasses.insert(EnclosingClass);
+        // Add the associated namespace for this class.
+        while (Ctx->isRecord())
+          Ctx = Ctx->getParent();
+        CollectNamespace(AssociatedNamespaces, Ctx);
+      }
+      break;
+
+    case TemplateArgument::Integral:
+    case TemplateArgument::Expression:
+      // [Note: non-type template arguments do not contribute to the set of
+      //  associated namespaces. ]
+      break;
+
+    case TemplateArgument::Pack:
+      for (TemplateArgument::pack_iterator P = Arg.pack_begin(),
+                                        PEnd = Arg.pack_end();
+           P != PEnd; ++P)
+        addAssociatedClassesAndNamespaces(*P, Context,
+                                          AssociatedNamespaces,
+                                          AssociatedClasses);
+      break;
+  }
+}
+
 // \brief Add the associated classes and namespaces for
-// argument-dependent lookup with an argument of class type 
-// (C++ [basic.lookup.koenig]p2). 
-static void 
-addAssociatedClassesAndNamespaces(CXXRecordDecl *Class, 
+// argument-dependent lookup with an argument of class type
+// (C++ [basic.lookup.koenig]p2).
+static void
+addAssociatedClassesAndNamespaces(CXXRecordDecl *Class,
                                   ASTContext &Context,
                             Sema::AssociatedNamespaceSet &AssociatedNamespaces,
-                            Sema::AssociatedClassSet &AssociatedClasses,
-                                  bool &GlobalScope) {
+                            Sema::AssociatedClassSet &AssociatedClasses) {
   // C++ [basic.lookup.koenig]p2:
   //   [...]
   //     -- If T is a class type (including unions), its associated
   //        classes are: the class itself; the class of which it is a
   //        member, if any; and its direct and indirect base
   //        classes. Its associated namespaces are the namespaces in
-  //        which its associated classes are defined. 
+  //        which its associated classes are defined.
 
   // Add the class of which it is a member, if any.
   DeclContext *Ctx = Class->getDeclContext();
@@ -1265,17 +1192,38 @@ addAssociatedClassesAndNamespaces(CXXRecordDecl *Class,
   // Add the associated namespace for this class.
   while (Ctx->isRecord())
     Ctx = Ctx->getParent();
-  if (NamespaceDecl *EnclosingNamespace = dyn_cast<NamespaceDecl>(Ctx))
-    AssociatedNamespaces.insert(EnclosingNamespace);
-  else if (Ctx->isTranslationUnit())
-    GlobalScope = true;
-  
+  CollectNamespace(AssociatedNamespaces, Ctx);
+
   // Add the class itself. If we've already seen this class, we don't
   // need to visit base classes.
   if (!AssociatedClasses.insert(Class))
     return;
 
-  // FIXME: Handle class template specializations
+  // -- If T is a template-id, its associated namespaces and classes are
+  //    the namespace in which the template is defined; for member
+  //    templates, the member template’s class; the namespaces and classes
+  //    associated with the types of the template arguments provided for
+  //    template type parameters (excluding template template parameters); the
+  //    namespaces in which any template template arguments are defined; and
+  //    the classes in which any member templates used as template template
+  //    arguments are defined. [Note: non-type template arguments do not
+  //    contribute to the set of associated namespaces. ]
+  if (ClassTemplateSpecializationDecl *Spec
+        = dyn_cast<ClassTemplateSpecializationDecl>(Class)) {
+    DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext();
+    if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
+      AssociatedClasses.insert(EnclosingClass);
+    // Add the associated namespace for this class.
+    while (Ctx->isRecord())
+      Ctx = Ctx->getParent();
+    CollectNamespace(AssociatedNamespaces, Ctx);
+
+    const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+    for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
+      addAssociatedClassesAndNamespaces(TemplateArgs[I], Context,
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
+  }
 
   // Add direct and indirect base classes along with their associated
   // namespaces.
@@ -1290,17 +1238,14 @@ addAssociatedClassesAndNamespaces(CXXRecordDecl *Class,
     for (CXXRecordDecl::base_class_iterator Base = Class->bases_begin(),
                                          BaseEnd = Class->bases_end();
          Base != BaseEnd; ++Base) {
-      const RecordType *BaseType = Base->getType()->getAsRecordType();
+      const RecordType *BaseType = Base->getType()->getAs<RecordType>();
       CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(BaseType->getDecl());
       if (AssociatedClasses.insert(BaseDecl)) {
         // Find the associated namespace for this base class.
         DeclContext *BaseCtx = BaseDecl->getDeclContext();
         while (BaseCtx->isRecord())
           BaseCtx = BaseCtx->getParent();
-        if (NamespaceDecl *EnclosingNamespace = dyn_cast<NamespaceDecl>(BaseCtx))
-          AssociatedNamespaces.insert(EnclosingNamespace);
-        else if (BaseCtx->isTranslationUnit())
-          GlobalScope = true;
+        CollectNamespace(AssociatedNamespaces, BaseCtx);
 
         // Make sure we visit the bases of this base class.
         if (BaseDecl->bases_begin() != BaseDecl->bases_end())
@@ -1312,13 +1257,12 @@ addAssociatedClassesAndNamespaces(CXXRecordDecl *Class,
 
 // \brief Add the associated classes and namespaces for
 // argument-dependent lookup with an argument of type T
-// (C++ [basic.lookup.koenig]p2). 
-static void 
-addAssociatedClassesAndNamespaces(QualType T, 
+// (C++ [basic.lookup.koenig]p2).
+static void
+addAssociatedClassesAndNamespaces(QualType T,
                                   ASTContext &Context,
                             Sema::AssociatedNamespaceSet &AssociatedNamespaces,
-                                  Sema::AssociatedClassSet &AssociatedClasses,
-                                  bool &GlobalScope) {
+                                  Sema::AssociatedClassSet &AssociatedClasses) {
   // C++ [basic.lookup.koenig]p2:
   //
   //   For each argument type T in the function call, there is a set
@@ -1332,44 +1276,43 @@ addAssociatedClassesAndNamespaces(QualType T,
   T = Context.getCanonicalType(T).getUnqualifiedType();
 
   //    -- If T is a pointer to U or an array of U, its associated
-  //       namespaces and classes are those associated with U. 
+  //       namespaces and classes are those associated with U.
   //
   // We handle this by unwrapping pointer and array types immediately,
   // to avoid unnecessary recursion.
   while (true) {
-    if (const PointerType *Ptr = T->getAsPointerType())
+    if (const PointerType *Ptr = T->getAs<PointerType>())
       T = Ptr->getPointeeType();
     else if (const ArrayType *Ptr = Context.getAsArrayType(T))
       T = Ptr->getElementType();
-    else 
+    else
       break;
   }
 
   //     -- If T is a fundamental type, its associated sets of
   //        namespaces and classes are both empty.
-  if (T->getAsBuiltinType())
+  if (T->getAs<BuiltinType>())
     return;
 
   //     -- If T is a class type (including unions), its associated
   //        classes are: the class itself; the class of which it is a
   //        member, if any; and its direct and indirect base
   //        classes. Its associated namespaces are the namespaces in
-  //        which its associated classes are defined. 
-  if (const RecordType *ClassType = T->getAsRecordType())
-    if (CXXRecordDecl *ClassDecl 
+  //        which its associated classes are defined.
+  if (const RecordType *ClassType = T->getAs<RecordType>())
+    if (CXXRecordDecl *ClassDecl
         = dyn_cast<CXXRecordDecl>(ClassType->getDecl())) {
-      addAssociatedClassesAndNamespaces(ClassDecl, Context, 
-                                        AssociatedNamespaces, 
-                                        AssociatedClasses,
-                                        GlobalScope);
+      addAssociatedClassesAndNamespaces(ClassDecl, Context,
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
       return;
     }
 
   //     -- If T is an enumeration type, its associated namespace is
   //        the namespace in which it is defined. If it is class
   //        member, its associated class is the member’s class; else
-  //        it has no associated class. 
-  if (const EnumType *EnumT = T->getAsEnumType()) {
+  //        it has no associated class.
+  if (const EnumType *EnumT = T->getAs<EnumType>()) {
     EnumDecl *Enum = EnumT->getDecl();
 
     DeclContext *Ctx = Enum->getDeclContext();
@@ -1379,10 +1322,7 @@ addAssociatedClassesAndNamespaces(QualType T,
     // Add the associated namespace for this class.
     while (Ctx->isRecord())
       Ctx = Ctx->getParent();
-    if (NamespaceDecl *EnclosingNamespace = dyn_cast<NamespaceDecl>(Ctx))
-      AssociatedNamespaces.insert(EnclosingNamespace);
-    else if (Ctx->isTranslationUnit())
-      GlobalScope = true;
+    CollectNamespace(AssociatedNamespaces, Ctx);
 
     return;
   }
@@ -1390,50 +1330,48 @@ addAssociatedClassesAndNamespaces(QualType T,
   //     -- If T is a function type, its associated namespaces and
   //        classes are those associated with the function parameter
   //        types and those associated with the return type.
-  if (const FunctionType *FunctionType = T->getAsFunctionType()) {
+  if (const FunctionType *FnType = T->getAs<FunctionType>()) {
     // Return type
-    addAssociatedClassesAndNamespaces(FunctionType->getResultType(), 
+    addAssociatedClassesAndNamespaces(FnType->getResultType(),
                                       Context,
-                                      AssociatedNamespaces, AssociatedClasses,
-                                      GlobalScope);
+                                      AssociatedNamespaces, AssociatedClasses);
 
-    const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FunctionType);
+    const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType);
     if (!Proto)
       return;
 
     // Argument types
     for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
-                                           ArgEnd = Proto->arg_type_end(); 
+                                           ArgEnd = Proto->arg_type_end();
          Arg != ArgEnd; ++Arg)
       addAssociatedClassesAndNamespaces(*Arg, Context,
-                                        AssociatedNamespaces, AssociatedClasses,
-                                        GlobalScope);
-      
+                                        AssociatedNamespaces, AssociatedClasses);
+
     return;
   }
 
   //     -- If T is a pointer to a member function of a class X, its
   //        associated namespaces and classes are those associated
   //        with the function parameter types and return type,
-  //        together with those associated with X. 
+  //        together with those associated with X.
   //
   //     -- If T is a pointer to a data member of class X, its
   //        associated namespaces and classes are those associated
   //        with the member type together with those associated with
-  //        X. 
-  if (const MemberPointerType *MemberPtr = T->getAsMemberPointerType()) {
+  //        X.
+  if (const MemberPointerType *MemberPtr = T->getAs<MemberPointerType>()) {
     // Handle the type that the pointer to member points to.
     addAssociatedClassesAndNamespaces(MemberPtr->getPointeeType(),
                                       Context,
-                                      AssociatedNamespaces, AssociatedClasses,
-                                      GlobalScope);
+                                      AssociatedNamespaces,
+                                      AssociatedClasses);
 
     // Handle the class type into which this points.
-    if (const RecordType *Class = MemberPtr->getClass()->getAsRecordType())
+    if (const RecordType *Class = MemberPtr->getClass()->getAs<RecordType>())
       addAssociatedClassesAndNamespaces(cast<CXXRecordDecl>(Class->getDecl()),
                                         Context,
-                                        AssociatedNamespaces, AssociatedClasses,
-                                        GlobalScope);
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
 
     return;
   }
@@ -1447,13 +1385,12 @@ addAssociatedClassesAndNamespaces(QualType T,
 /// arguments.
 ///
 /// This routine computes the sets of associated classes and associated
-/// namespaces searched by argument-dependent lookup 
+/// namespaces searched by argument-dependent lookup
 /// (C++ [basic.lookup.argdep]) for a given set of arguments.
-void 
+void
 Sema::FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
                                  AssociatedNamespaceSet &AssociatedNamespaces,
-                                 AssociatedClassSet &AssociatedClasses,
-                                         bool &GlobalScope) {
+                                 AssociatedClassSet &AssociatedClasses) {
   AssociatedNamespaces.clear();
   AssociatedClasses.clear();
 
@@ -1463,14 +1400,14 @@ Sema::FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
   //   associated classes to be considered. The sets of namespaces and
   //   classes is determined entirely by the types of the function
   //   arguments (and the namespace of any template template
-  //   argument). 
+  //   argument).
   for (unsigned ArgIdx = 0; ArgIdx != NumArgs; ++ArgIdx) {
     Expr *Arg = Args[ArgIdx];
 
     if (Arg->getType() != Context.OverloadTy) {
       addAssociatedClassesAndNamespaces(Arg->getType(), Context,
-                                        AssociatedNamespaces, AssociatedClasses,
-                                        GlobalScope);
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
       continue;
     }
 
@@ -1482,16 +1419,23 @@ Sema::FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
     // classes and namespaces associated with its (non-dependent)
     // parameter types and return type.
     DeclRefExpr *DRE = 0;
+    TemplateIdRefExpr *TIRE = 0;
+    Arg = Arg->IgnoreParens();
     if (UnaryOperator *unaryOp = dyn_cast<UnaryOperator>(Arg)) {
-      if (unaryOp->getOpcode() == UnaryOperator::AddrOf)
+      if (unaryOp->getOpcode() == UnaryOperator::AddrOf) {
         DRE = dyn_cast<DeclRefExpr>(unaryOp->getSubExpr());
-    } else
+        TIRE = dyn_cast<TemplateIdRefExpr>(unaryOp->getSubExpr());
+      }
+    } else {
       DRE = dyn_cast<DeclRefExpr>(Arg);
-    if (!DRE)
-      continue;
+      TIRE = dyn_cast<TemplateIdRefExpr>(Arg);
+    }
 
-    OverloadedFunctionDecl *Ovl 
-      = dyn_cast<OverloadedFunctionDecl>(DRE->getDecl());
+    OverloadedFunctionDecl *Ovl = 0;
+    if (DRE)
+      Ovl = dyn_cast<OverloadedFunctionDecl>(DRE->getDecl());
+    else if (TIRE)
+      Ovl = TIRE->getTemplateName().getAsOverloadedFunctionDecl();
     if (!Ovl)
       continue;
 
@@ -1506,16 +1450,13 @@ Sema::FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
       // that, if this is a member function, we do *not* consider the
       // enclosing namespace of its class.
       DeclContext *Ctx = FDecl->getDeclContext();
-      if (NamespaceDecl *EnclosingNamespace = dyn_cast<NamespaceDecl>(Ctx))
-        AssociatedNamespaces.insert(EnclosingNamespace);
-      else if (Ctx->isTranslationUnit())
-        GlobalScope = true;
+      CollectNamespace(AssociatedNamespaces, Ctx);
 
       // Add the classes and namespaces associated with the parameter
       // types and return type of this function.
       addAssociatedClassesAndNamespaces(FDecl->getType(), Context,
-                                        AssociatedNamespaces, AssociatedClasses,
-                                        GlobalScope);
+                                        AssociatedNamespaces,
+                                        AssociatedClasses);
     }
   }
 }
@@ -1525,7 +1466,7 @@ Sema::FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
 /// arguments have types T1 (and, if non-empty, T2). This routine
 /// implements the check in C++ [over.match.oper]p3b2 concerning
 /// enumeration types.
-static bool 
+static bool
 IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn,
                                        QualType T1, QualType T2,
                                        ASTContext &Context) {
@@ -1535,7 +1476,7 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn,
   if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
     return true;
 
-  const FunctionProtoType *Proto = Fn->getType()->getAsFunctionProtoType();
+  const FunctionProtoType *Proto = Fn->getType()->getAs<FunctionProtoType>();
   if (Proto->getNumArgs() < 1)
     return false;
 
@@ -1561,26 +1502,19 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn,
 
 /// \brief Find the protocol with the given name, if any.
 ObjCProtocolDecl *Sema::LookupProtocol(IdentifierInfo *II) {
-  Decl *D = LookupName(TUScope, II, LookupObjCProtocolName).getAsDecl();
+  Decl *D = LookupSingleName(TUScope, II, LookupObjCProtocolName);
   return cast_or_null<ObjCProtocolDecl>(D);
 }
 
-/// \brief Find the Objective-C implementation with the given name, if
-/// any.
-ObjCImplementationDecl *Sema::LookupObjCImplementation(IdentifierInfo *II) {
-  Decl *D = LookupName(TUScope, II, LookupObjCImplementationName).getAsDecl();
-  return cast_or_null<ObjCImplementationDecl>(D);
-}
-
 /// \brief Find the Objective-C category implementation with the given
 /// name, if any.
 ObjCCategoryImplDecl *Sema::LookupObjCCategoryImpl(IdentifierInfo *II) {
-  Decl *D = LookupName(TUScope, II, LookupObjCCategoryImplName).getAsDecl();
+  Decl *D = LookupSingleName(TUScope, II, LookupObjCCategoryImplName);
   return cast_or_null<ObjCCategoryImplDecl>(D);
 }
 
 void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
-                                        QualType T1, QualType T2, 
+                                        QualType T1, QualType T2,
                                         FunctionSet &Functions) {
   // C++ [over.match.oper]p3:
   //     -- The set of non-member candidates is the result of the
@@ -1589,17 +1523,18 @@ void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
   //        unqualified function calls (3.4.2) except that all member
   //        functions are ignored. However, if no operand has a class
   //        type, only those non-member functions in the lookup set
-  //        that have a first parameter of type T1 or “reference to
-  //        (possibly cv-qualified) T1”, when T1 is an enumeration
+  //        that have a first parameter of type T1 or "reference to
+  //        (possibly cv-qualified) T1", when T1 is an enumeration
   //        type, or (if there is a right operand) a second parameter
-  //        of type T2 or “reference to (possibly cv-qualified) T2”,
+  //        of type T2 or "reference to (possibly cv-qualified) T2",
   //        when T2 is an enumeration type, are candidate functions.
   DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
-  LookupResult Operators = LookupName(S, OpName, LookupOperatorName);
-  
+  LookupResult Operators;
+  LookupName(Operators, S, OpName, LookupOperatorName);
+
   assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
 
-  if (!Operators)
+  if (Operators.empty())
     return;
 
   for (LookupResult::iterator Op = Operators.begin(), OpEnd = Operators.end();
@@ -1607,10 +1542,10 @@ void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*Op)) {
       if (IsAcceptableNonMemberOperatorCandidate(FD, T1, T2, Context))
         Functions.insert(FD); // FIXME: canonical FD
-    } else if (FunctionTemplateDecl *FunTmpl 
+    } else if (FunctionTemplateDecl *FunTmpl
                  = dyn_cast<FunctionTemplateDecl>(*Op)) {
       // FIXME: friend operators?
-      // FIXME: do we need to check IsAcceptableNonMemberOperatorCandidate, 
+      // FIXME: do we need to check IsAcceptableNonMemberOperatorCandidate,
       // later?
       if (!FunTmpl->getDeclContext()->isRecord())
         Functions.insert(FunTmpl);
@@ -1618,6 +1553,14 @@ void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
   }
 }
 
+static void CollectFunctionDecl(Sema::FunctionSet &Functions,
+                                Decl *D) {
+  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
+    Functions.insert(Func);
+  else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
+    Functions.insert(FunTmpl);
+}
+
 void Sema::ArgumentDependentLookup(DeclarationName Name,
                                    Expr **Args, unsigned NumArgs,
                                    FunctionSet &Functions) {
@@ -1625,10 +1568,9 @@ void Sema::ArgumentDependentLookup(DeclarationName Name,
   // arguments we have.
   AssociatedNamespaceSet AssociatedNamespaces;
   AssociatedClassSet AssociatedClasses;
-  bool GlobalScope = false;
-  FindAssociatedClassesAndNamespaces(Args, NumArgs, 
-                                     AssociatedNamespaces, AssociatedClasses,
-                                     GlobalScope);
+  FindAssociatedClassesAndNamespaces(Args, NumArgs,
+                                     AssociatedNamespaces,
+                                     AssociatedClasses);
 
   // C++ [basic.lookup.argdep]p3:
   //   Let X be the lookup set produced by unqualified lookup (3.4.1)
@@ -1642,8 +1584,8 @@ void Sema::ArgumentDependentLookup(DeclarationName Name,
   // Here, we compute Y and add its members to the overloaded
   // candidate set.
   for (AssociatedNamespaceSet::iterator NS = AssociatedNamespaces.begin(),
-                                     NSEnd = AssociatedNamespaces.end(); 
-       NS != NSEnd; ++NS) { 
+                                     NSEnd = AssociatedNamespaces.end();
+       NS != NSEnd; ++NS) {
     //   When considering an associated namespace, the lookup is the
     //   same as the lookup performed when the associated namespace is
     //   used as a qualifier (3.4.3.2) except that:
@@ -1651,28 +1593,22 @@ void Sema::ArgumentDependentLookup(DeclarationName Name,
     //     -- Any using-directives in the associated namespace are
     //        ignored.
     //
-    //     -- FIXME: Any namespace-scope friend functions declared in
+    //     -- Any namespace-scope friend functions declared in
     //        associated classes are visible within their respective
     //        namespaces even if they are not visible during an ordinary
     //        lookup (11.4).
     DeclContext::lookup_iterator I, E;
     for (llvm::tie(I, E) = (*NS)->lookup(Name); I != E; ++I) {
-      if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*I))
-        Functions.insert(Func);
-      else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(*I))
-        Functions.insert(FunTmpl);
-    }
-  }
-  
-  if (GlobalScope) {
-    DeclContext::lookup_iterator I, E;
-    for (llvm::tie(I, E) 
-           = Context.getTranslationUnitDecl()->lookup(Name); 
-         I != E; ++I) {
-      if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*I))
-        Functions.insert(Func);
-      else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(*I))
-        Functions.insert(FunTmpl);
+      Decl *D = *I;
+      // If the only declaration here is an ordinary friend, consider
+      // it only if it was declared in an associated classes.
+      if (D->getIdentifierNamespace() == Decl::IDNS_OrdinaryFriend) {
+        DeclContext *LexDC = D->getLexicalDeclContext();
+        if (!AssociatedClasses.count(cast<CXXRecordDecl>(LexDC)))
+          continue;
+      }
+
+      CollectFunctionDecl(Functions, D);
     }
   }
 }