diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h index 990403e7dc..10ed99a189 100644 --- a/include/clang/AST/DeclCXX.h +++ b/include/clang/AST/DeclCXX.h @@ -88,108 +88,6 @@ namespace llvm { namespace clang { -/// OverloadedFunctionDecl - An instance of this class represents a -/// set of overloaded functions. All of the functions have the same -/// name and occur within the same scope. -/// -/// An OverloadedFunctionDecl has no ownership over the FunctionDecl -/// nodes it contains. Rather, the FunctionDecls are owned by the -/// enclosing scope (which also owns the OverloadedFunctionDecl -/// node). OverloadedFunctionDecl is used primarily to store a set of -/// overloaded functions for name lookup. -class OverloadedFunctionDecl : public NamedDecl { -protected: - OverloadedFunctionDecl(DeclContext *DC, DeclarationName N) - : NamedDecl(OverloadedFunction, DC, SourceLocation(), N) { } - - /// Functions - the set of overloaded functions contained in this - /// overload set. - llvm::SmallVector Functions; - - // FIXME: This should go away when we stop using - // OverloadedFunctionDecl to store conversions in CXXRecordDecl. - friend class CXXRecordDecl; - -public: - typedef llvm::SmallVector::iterator function_iterator; - typedef llvm::SmallVector::const_iterator - function_const_iterator; - - static OverloadedFunctionDecl *Create(ASTContext &C, DeclContext *DC, - DeclarationName N); - - /// \brief Add a new overloaded function or function template to the set - /// of overloaded function templates. - void addOverload(AnyFunctionDecl F); - - function_iterator function_begin() { return Functions.begin(); } - function_iterator function_end() { return Functions.end(); } - function_const_iterator function_begin() const { return Functions.begin(); } - function_const_iterator function_end() const { return Functions.end(); } - - /// \brief Returns the number of overloaded functions stored in - /// this set. - unsigned size() const { return Functions.size(); } - - // Implement isa/cast/dyncast/etc. - static bool classof(const Decl *D) { - return D->getKind() == OverloadedFunction; - } - static bool classof(const OverloadedFunctionDecl *D) { return true; } -}; - -/// \brief Provides uniform iteration syntax for an overload set, function, -/// or function template. -class OverloadIterator { - /// \brief An overloaded function set, function declaration, or - /// function template declaration. - NamedDecl *D; - - /// \brief If the declaration is an overloaded function set, this is the - /// iterator pointing to the current position within that overloaded - /// function set. - OverloadedFunctionDecl::function_iterator Iter; - -public: - typedef AnyFunctionDecl value_type; - typedef value_type reference; - typedef NamedDecl *pointer; - typedef int difference_type; - typedef std::forward_iterator_tag iterator_category; - - OverloadIterator() : D(0) { } - - OverloadIterator(FunctionDecl *FD) : D(FD) { } - OverloadIterator(FunctionTemplateDecl *FTD) - : D(reinterpret_cast(FTD)) { } - OverloadIterator(OverloadedFunctionDecl *Ovl) - : D(Ovl), Iter(Ovl->function_begin()) { } - - OverloadIterator(NamedDecl *ND); - - reference operator*() const; - - pointer operator->() const { return (**this).get(); } - - OverloadIterator &operator++(); - - OverloadIterator operator++(int) { - OverloadIterator Temp(*this); - ++(*this); - return Temp; - } - - bool Equals(const OverloadIterator &Other) const; -}; - -inline bool operator==(const OverloadIterator &X, const OverloadIterator &Y) { - return X.Equals(Y); -} - -inline bool operator!=(const OverloadIterator &X, const OverloadIterator &Y) { - return !(X == Y); -} - /// CXXBaseSpecifier - A base class of a C++ class. /// /// Each CXXBaseSpecifier represents a single, direct base class (or diff --git a/include/clang/AST/DeclNodes.def b/include/clang/AST/DeclNodes.def index ec1b3b055c..082299c41f 100644 --- a/include/clang/AST/DeclNodes.def +++ b/include/clang/AST/DeclNodes.def @@ -75,7 +75,6 @@ DECL(TranslationUnit, Decl) ABSTRACT_DECL(Named, Decl) - DECL(OverloadedFunction, NamedDecl) DECL(Namespace, NamedDecl) DECL(UsingDirective, NamedDecl) DECL(NamespaceAlias, NamedDecl) @@ -143,7 +142,7 @@ DECL_CONTEXT_BASE(ObjCContainer) LAST_DECL_CONTEXT(Block) // Declaration ranges -DECL_RANGE(Named, OverloadedFunction, ObjCCompatibleAlias) +DECL_RANGE(Named, Namespace, ObjCCompatibleAlias) DECL_RANGE(ObjCContainer, ObjCContainer, ObjCImplementation) DECL_RANGE(Field, Field, ObjCAtDefsField) DECL_RANGE(Type, Typedef, TemplateTypeParm) diff --git a/lib/AST/DeclBase.cpp b/lib/AST/DeclBase.cpp index 2dcd80b01f..f276faf1be 100644 --- a/lib/AST/DeclBase.cpp +++ b/lib/AST/DeclBase.cpp @@ -190,7 +190,6 @@ unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { case CXXConstructor: case CXXDestructor: case CXXConversion: - case OverloadedFunction: case Typedef: case EnumConstant: case Var: diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp index 4001988007..d850e4fd0a 100644 --- a/lib/AST/DeclCXX.cpp +++ b/lib/AST/DeclCXX.cpp @@ -797,64 +797,6 @@ CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD, return new (C) CXXConversionDecl(RD, L, N, T, DInfo, isInline, isExplicit); } -OverloadedFunctionDecl * -OverloadedFunctionDecl::Create(ASTContext &C, DeclContext *DC, - DeclarationName N) { - return new (C) OverloadedFunctionDecl(DC, N); -} - -OverloadIterator::OverloadIterator(NamedDecl *ND) : D(0) { - if (!ND) - return; - - if (isa(ND) || isa(ND)) - D = ND; - else if (OverloadedFunctionDecl *Ovl = dyn_cast(ND)) { - if (Ovl->size() != 0) { - D = ND; - Iter = Ovl->function_begin(); - } - } -} - -void OverloadedFunctionDecl::addOverload(AnyFunctionDecl F) { - Functions.push_back(F); - this->setLocation(F.get()->getLocation()); -} - -OverloadIterator::reference OverloadIterator::operator*() const { - if (FunctionDecl *FD = dyn_cast(D)) - return FD; - - if (FunctionTemplateDecl *FTD = dyn_cast(D)) - return FTD; - - assert(isa(D)); - return *Iter; -} - -OverloadIterator &OverloadIterator::operator++() { - if (isa(D) || isa(D)) { - D = 0; - return *this; - } - - if (++Iter == cast(D)->function_end()) - D = 0; - - return *this; -} - -bool OverloadIterator::Equals(const OverloadIterator &Other) const { - if (!D || !Other.D) - return D == Other.D; - - if (D != Other.D) - return false; - - return !isa(D) || Iter == Other.Iter; -} - FriendDecl *FriendDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend, diff --git a/lib/AST/DeclPrinter.cpp b/lib/AST/DeclPrinter.cpp index a5982cfd97..2c3b927e43 100644 --- a/lib/AST/DeclPrinter.cpp +++ b/lib/AST/DeclPrinter.cpp @@ -52,7 +52,6 @@ namespace { void VisitVarDecl(VarDecl *D); void VisitParmVarDecl(ParmVarDecl *D); void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); - void VisitOverloadedFunctionDecl(OverloadedFunctionDecl *D); void VisitNamespaceDecl(NamespaceDecl *D); void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); @@ -488,11 +487,6 @@ void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { //---------------------------------------------------------------------------- // C++ declarations //---------------------------------------------------------------------------- -void DeclPrinter::VisitOverloadedFunctionDecl(OverloadedFunctionDecl *D) { - assert(false && - "OverloadedFunctionDecls aren't really decls and are never printed"); -} - void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) { Out << "namespace " << D->getNameAsString() << " {\n"; VisitDeclContext(D); diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 624a620b9f..28f1bd92f3 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -118,7 +118,6 @@ DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier, (Qualifier? HasQualifierFlag : 0) | (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)), Loc(NameLoc) { - assert(!isa(D)); if (Qualifier) { NameQualifier *NQ = getNameQualifier(); NQ->NNS = Qualifier; @@ -944,8 +943,7 @@ static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { return isa(Decl) || isa(Decl) || // C++ 3.10p2: An lvalue refers to an object or function. (Ctx.getLangOptions().CPlusPlus && - (isa(Decl) || isa(Decl) || - isa(Decl))); + (isa(Decl) || isa(Decl))); } /// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index 1b6b022901..e2d772b7dd 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -659,13 +659,6 @@ void StmtProfiler::VisitDecl(Decl *D) { ID.AddInteger(TTP->getIndex()); return; } - - if (OverloadedFunctionDecl *Ovl = dyn_cast(D)) { - // The Itanium C++ ABI mangles references to a set of overloaded - // functions using just the function name, so we do the same here. - VisitName(Ovl->getDeclName()); - return; - } } ID.AddPointer(D? D->getCanonicalDecl() : 0); diff --git a/lib/Sema/Lookup.h b/lib/Sema/Lookup.h index 61d8a4ea33..78f79eac2b 100644 --- a/lib/Sema/Lookup.h +++ b/lib/Sema/Lookup.h @@ -33,12 +33,11 @@ public: NotFound = 0, /// @brief Name lookup found a single declaration that met the - /// criteria. getAsDecl will return this declaration. + /// criteria. getFoundDecl() will return this declaration. Found, /// @brief Name lookup found a set of overloaded functions that - /// met the criteria. getAsDecl will turn this set of overloaded - /// functions into an OverloadedFunctionDecl. + /// met the criteria. FoundOverloaded, /// @brief Name lookup found an unresolvable value declaration diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 726e4a01a4..fdeda40ea2 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -255,12 +255,13 @@ void ImplicitConversionSequence::DebugPrint() const { } // IsOverload - Determine whether the given New declaration is an -// overload of the Old declaration. This routine returns false if New -// and Old cannot be overloaded, e.g., if they are functions with the -// same signature (C++ 1.3.10) or if the Old declaration isn't a -// function (or overload set). When it does return false and Old is an -// OverloadedFunctionDecl, MatchedDecl will be set to point to the -// FunctionDecl that New cannot be overloaded with. +// overload of the declarations in Old. This routine returns false if +// New and Old cannot be overloaded, e.g., if New has the same +// signature as some function in Old (C++ 1.3.10) or if the Old +// declarations aren't functions (or function templates) at all. When +// it does return false and Old is an overload set, MatchedDecl will +// be set to point to the FunctionDecl that New cannot be overloaded +// with. // // Example: Given the following input: // @@ -271,37 +272,37 @@ void ImplicitConversionSequence::DebugPrint() const { // When we process #1, there is no previous declaration of "f", // so IsOverload will not be used. // -// When we process #2, Old is a FunctionDecl for #1. By comparing the -// parameter types, we see that #1 and #2 are overloaded (since they -// have different signatures), so this routine returns false; -// MatchedDecl is unchanged. +// When we process #2, Old contains only the FunctionDecl for #1. By +// comparing the parameter types, we see that #1 and #2 are overloaded +// (since they have different signatures), so this routine returns +// false; MatchedDecl is unchanged. // -// When we process #3, Old is an OverloadedFunctionDecl containing #1 -// and #2. We compare the signatures of #3 to #1 (they're overloaded, -// so we do nothing) and then #3 to #2. Since the signatures of #3 and -// #2 are identical (return types of functions are not part of the +// When we process #3, Old is an overload set containing #1 and #2. We +// compare the signatures of #3 to #1 (they're overloaded, so we do +// nothing) and then #3 to #2. Since the signatures of #3 and #2 are +// identical (return types of functions are not part of the // signature), IsOverload returns false and MatchedDecl will be set to // point to the FunctionDecl for #2. bool -Sema::IsOverload(FunctionDecl *New, LookupResult &Previous, NamedDecl *&Match) { - for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); +Sema::IsOverload(FunctionDecl *New, LookupResult &Old, NamedDecl *&Match) { + for (LookupResult::iterator I = Old.begin(), E = Old.end(); I != E; ++I) { - NamedDecl *Old = (*I)->getUnderlyingDecl(); - if (FunctionTemplateDecl *OldT = dyn_cast(Old)) { + NamedDecl *OldD = (*I)->getUnderlyingDecl(); + if (FunctionTemplateDecl *OldT = dyn_cast(OldD)) { if (!IsOverload(New, OldT->getTemplatedDecl())) { - Match = Old; + Match = OldT; return false; } - } else if (FunctionDecl *OldF = dyn_cast(Old)) { + } else if (FunctionDecl *OldF = dyn_cast(OldD)) { if (!IsOverload(New, OldF)) { - Match = Old; + Match = OldF; return false; } } else { // (C++ 13p1): // Only function declarations can be overloaded; object and type // declarations cannot be overloaded. - Match = Old; + Match = OldD; return false; } }