Revert r102215. This causes clang crash while compiling a test case from gdb testsuite.

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

include/clang/AST/DeclBase.h

@@ -132,12 +132,7 @@ public:
     /// *introduces* a number of other declarations into the current
     /// scope, and those declarations use the IDNS of their targets,
     /// but the actual using declarations go in this namespace.
-    IDNS_Using               = 0x0200,
-
-    /// This declaration is a C++ operator declared in a non-class
-    /// context.  All such operators are also in IDNS_Ordinary.
-    /// C++ lexical operator lookup looks for these.
-    IDNS_NonMemberOperator   = 0x0400
+    IDNS_Using               = 0x0200
   };
 
   /// ObjCDeclQualifier - Qualifier used on types in method declarations
@@ -538,14 +533,6 @@ public:
               FOK_Declared : FOK_Undeclared);
   }
 
-  /// Specifies that this declaration is a C++ overloaded non-member.
-  void setNonMemberOperator() {
-    assert(getKind() == Function || getKind() == FunctionTemplate);
-    assert((IdentifierNamespace & IDNS_Ordinary) &&
-           "visible non-member operators should be in ordinary namespace");
-    IdentifierNamespace |= IDNS_NonMemberOperator;
-  }
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *) { return true; }
   static bool classofKind(Kind K) { return true; }

lib/CodeGen/CGDebugInfo.cpp

@@ -1333,9 +1333,21 @@ void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
 
   llvm::StringRef Name;
   MangleBuffer LinkageName;
+  // It is expected that CurLoc is set before using EmitFunctionStart.
+  // Usually, CurLoc points to the left bracket location of compound
+  // statement representing function body.
+  llvm::DIFile Unit = getOrCreateFile(CurLoc);
+  llvm::DIDescriptor Context(Unit.getNode());
 
   const Decl *D = GD.getDecl();
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
+      if (MD->isStatic()) {
+        QualType RTy = CGM.getContext().getTypeDeclType(MD->getParent());
+        Context = CreateType(RTy->getAs<RecordType>(), getOrCreateFile(CurLoc));
+      }
+    }
+
     // If there is a DISubprogram for  this function available then use it.
     llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
       FI = SPCache.find(FD);
@@ -1360,15 +1372,11 @@ void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
       Name = Name.substr(1);
   }
 
-  // It is expected that CurLoc is set before using EmitFunctionStart.
-  // Usually, CurLoc points to the left bracket location of compound
-  // statement representing function body.
-  llvm::DIFile Unit = getOrCreateFile(CurLoc);
   SourceManager &SM = CGM.getContext().getSourceManager();
   unsigned LineNo = SM.getPresumedLoc(CurLoc).getLine();
 
   llvm::DISubprogram SP =
-    DebugFactory.CreateSubprogram(Unit, Name, Name, LinkageName, Unit, LineNo,
+    DebugFactory.CreateSubprogram(Context, Name, Name, LinkageName, Unit, LineNo,
                                   getOrCreateType(FnType, Unit),
                                   Fn->hasInternalLinkage(), true/*definition*/);
 

lib/Frontend/PCHReaderDecl.cpp

@@ -197,11 +197,6 @@ void PCHDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   for (unsigned I = 0; I != NumParams; ++I)
     Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
   FD->setParams(Params.data(), NumParams);
-
-  // FIXME: order this properly w.r.t. friendness
-  // FIXME: this same thing needs to happen for function templates
-  if (FD->isOverloadedOperator() && !FD->getDeclContext()->isRecord())
-    FD->setNonMemberOperator();
 }
 
 void PCHDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {

lib/Sema/Lookup.h

@@ -124,6 +124,7 @@ public:
   };
 
   typedef UnresolvedSetImpl::iterator iterator;
+  typedef bool (*ResultFilter)(NamedDecl*, unsigned IDNS);
 
   LookupResult(Sema &SemaRef, DeclarationName Name, SourceLocation NameLoc,
                Sema::LookupNameKind LookupKind,
@@ -135,6 +136,7 @@ public:
       Name(Name),
       NameLoc(NameLoc),
       LookupKind(LookupKind),
+      IsAcceptableFn(0),
       IDNS(0),
       Redecl(Redecl != Sema::NotForRedeclaration),
       HideTags(true),
@@ -154,6 +156,7 @@ public:
       Name(Other.Name),
       NameLoc(Other.NameLoc),
       LookupKind(Other.LookupKind),
+      IsAcceptableFn(Other.IsAcceptableFn),
       IDNS(Other.IDNS),
       Redecl(Other.Redecl),
       HideTags(Other.HideTags),
@@ -239,7 +242,8 @@ public:
 
   /// \brief Tests whether the given declaration is acceptable.
   bool isAcceptableDecl(NamedDecl *D) const {
-    return D->isInIdentifierNamespace(IDNS);
+    assert(IsAcceptableFn);
+    return IsAcceptableFn(D, IDNS);
   }
 
   /// \brief Returns the identifier namespace mask for this lookup.
@@ -571,6 +575,7 @@ private:
   SourceLocation NameLoc;
   SourceRange NameContextRange;
   Sema::LookupNameKind LookupKind;
+  ResultFilter IsAcceptableFn; // set by configure()
   unsigned IDNS; // set by configure()
 
   bool Redecl;

lib/Sema/SemaDecl.cpp

@@ -3269,12 +3269,6 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
     NewFD->setAccess(Access);
   }
 
-  if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
-      NewFD->isInIdentifierNamespace(Decl::IDNS_Ordinary)) {
-    NewFD->setNonMemberOperator();
-    if (FunctionTemplate) FunctionTemplate->setNonMemberOperator();
-  }
-
   // If we have a function template, check the template parameter
   // list. This will check and merge default template arguments.
   if (FunctionTemplate) {

lib/Sema/SemaLookup.cpp

@@ -193,6 +193,37 @@ namespace {
   };
 }
 
+static bool IsAcceptableIDNS(NamedDecl *D, unsigned IDNS) {
+  return D->isInIdentifierNamespace(IDNS);
+}
+
+static bool IsAcceptableOperatorName(NamedDecl *D, unsigned IDNS) {
+  return D->isInIdentifierNamespace(IDNS) &&
+    !D->getDeclContext()->isRecord();
+}
+
+/// Gets the default result filter for the given lookup.
+static inline
+LookupResult::ResultFilter getResultFilter(Sema::LookupNameKind NameKind) {
+  switch (NameKind) {
+  case Sema::LookupOrdinaryName:
+  case Sema::LookupTagName:
+  case Sema::LookupMemberName:
+  case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
+  case Sema::LookupUsingDeclName:
+  case Sema::LookupObjCProtocolName:
+  case Sema::LookupNestedNameSpecifierName:
+  case Sema::LookupNamespaceName:
+    return &IsAcceptableIDNS;
+
+  case Sema::LookupOperatorName:
+    return &IsAcceptableOperatorName;
+  }
+
+  llvm_unreachable("unkknown lookup kind");
+  return 0;
+}
+
 // Retrieve the set of identifier namespaces that correspond to a
 // specific kind of name lookup.
 static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
@@ -201,6 +232,7 @@ static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
   unsigned IDNS = 0;
   switch (NameKind) {
   case Sema::LookupOrdinaryName:
+  case Sema::LookupOperatorName:
   case Sema::LookupRedeclarationWithLinkage:
     IDNS = Decl::IDNS_Ordinary;
     if (CPlusPlus) {
@@ -209,13 +241,6 @@ static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
     }
     break;
 
-  case Sema::LookupOperatorName:
-    // Operator lookup is its own crazy thing;  it is not the same
-    // as (e.g.) looking up an operator name for redeclaration.
-    assert(!Redeclaration && "cannot do redeclaration operator lookup");
-    IDNS = Decl::IDNS_NonMemberOperator;
-    break;
-
   case Sema::LookupTagName:
     if (CPlusPlus) {
       IDNS = Decl::IDNS_Type;
@@ -262,6 +287,7 @@ void LookupResult::configure() {
   IDNS = getIDNS(LookupKind,
                  SemaRef.getLangOptions().CPlusPlus,
                  isForRedeclaration());
+  IsAcceptableFn = getResultFilter(LookupKind);
 
   // If we're looking for one of the allocation or deallocation
   // operators, make sure that the implicitly-declared new and delete

lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -1140,12 +1140,6 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
     DC->makeDeclVisibleInContext(ToFriendD, /*Recoverable=*/ false);
   }
 
-  if (Function->isOverloadedOperator() && !DC->isRecord() &&
-      Function->isInIdentifierNamespace(Decl::IDNS_Ordinary)) {
-    Function->setNonMemberOperator();
-    if (FunctionTemplate) FunctionTemplate->setNonMemberOperator();
-  }
-
   return Function;
 }