mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-27 16:26:06 +00:00
Code Issues Projects Releases Wiki Activity

Cleanup: remove artificial division between lookup results and const lookup

Browse Source 
results. No-one was ever modifying a lookup result, and it would not be
reasonable to do so.

llvm-svn: 230123
This commit is contained in:
Richard Smith 2015-02-21 02:45:19 +00:00
parent 8d981962c0
commit cf4bdde33a
13 changed files with 33 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
clang/include/clang/AST/DeclBase.h
View File

@ -1063,9 +1063,6 @@ public:
}
};
// FIXME: Remove this.
typedef DeclContextLookupResult DeclContextLookupConstResult;
/// DeclContext - This is used only as base class of specific decl types that
/// can act as declaration contexts. These decls are (only the top classes
/// that directly derive from DeclContext are mentioned, not their subclasses):
@ -1580,10 +1577,6 @@ public:
typedef DeclContextLookupResult lookup_result;
typedef lookup_result::iterator lookup_iterator;
// FIXME: Remove these.
typedef lookup_result lookup_const_result;
typedef lookup_iterator lookup_const_iterator;
/// lookup - Find the declarations (if any) with the given Name in
/// this context. Returns a range of iterators that contains all of
/// the declarations with this name, with object, function, member,

4
clang/lib/ARCMigrate/ObjCMT.cpp
View File

@ -624,7 +624,7 @@ ClassImplementsAllMethodsAndProperties(ASTContext &Ctx,
if (Property->getPropertyImplementation() == ObjCPropertyDecl::Optional)
continue;
HasAtleastOneRequiredProperty = true;
DeclContext::lookup_const_result R = IDecl->lookup(Property->getDeclName());
DeclContext::lookup_result R = IDecl->lookup(Property->getDeclName());
if (R.size() == 0) {
// Relax the rule and look into class's implementation for a synthesize
// or dynamic declaration. Class is implementing a property coming from
@ -655,7 +655,7 @@ ClassImplementsAllMethodsAndProperties(ASTContext &Ctx,
continue;
if (MD->getImplementationControl() == ObjCMethodDecl::Optional)
continue;
DeclContext::lookup_const_result R = ImpDecl->lookup(MD->getDeclName());
DeclContext::lookup_result R = ImpDecl->lookup(MD->getDeclName());
if (R.size() == 0)
return false;
bool match = false;

4
clang/lib/AST/Decl.cpp
View File

@ -2532,8 +2532,8 @@ FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const {
// This is a sized deallocation function. Find the corresponding unsized
// deallocation function.
lookup_const_result R = getDeclContext()->lookup(getDeclName());
for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE;
lookup_result R = getDeclContext()->lookup(getDeclName());
for (lookup_result::iterator RI = R.begin(), RE = R.end(); RI != RE;
++RI)
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI))
if (FD->getNumParams() == 1 && !FD->isVariadic())

2
clang/lib/AST/DeclBase.cpp
View File

@ -1585,7 +1585,7 @@ UsingDirectiveDecl *DeclContext::udir_iterator::operator*() const {
DeclContext::udir_range DeclContext::using_directives() const {
// FIXME: Use something more efficient than normal lookup for using
// directives. In C++, using directives are looked up more than anything else.
lookup_const_result Result = lookup(UsingDirectiveDecl::getName());
lookup_result Result = lookup(UsingDirectiveDecl::getName());
return udir_range(Result.begin(), Result.end());
}

10
clang/lib/AST/DeclCXX.cpp
View File

@ -991,7 +991,7 @@ CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const {
if (!isLambda()) return nullptr;
DeclarationName Name =
getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
DeclContext::lookup_const_result Calls = lookup(Name);
DeclContext::lookup_result Calls = lookup(Name);
assert(!Calls.empty() && "Missing lambda call operator!");
assert(Calls.size() == 1 && "More than one lambda call operator!");
@ -1008,7 +1008,7 @@ CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
if (!isLambda()) return nullptr;
DeclarationName Name =
&getASTContext().Idents.get(getLambdaStaticInvokerName());
DeclContext::lookup_const_result Invoker = lookup(Name);
DeclContext::lookup_result Invoker = lookup(Name);
if (Invoker.empty()) return nullptr;
assert(Invoker.size() == 1 && "More than one static invoker operator!");
NamedDecl *InvokerFun = Invoker.front();
@ -1307,7 +1307,7 @@ CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
= Context.DeclarationNames.getCXXDestructorName(
Context.getCanonicalType(ClassType));
DeclContext::lookup_const_result R = lookup(Name);
DeclContext::lookup_result R = lookup(Name);
if (R.empty())
return nullptr;
@ -1490,8 +1490,8 @@ bool CXXMethodDecl::isUsualDeallocationFunction() const {
// This function is a usual deallocation function if there are no
// single-parameter deallocation functions of the same kind.
DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
for (DeclContext::lookup_const_result::iterator I = R.begin(), E = R.end();
DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName());
for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
I != E; ++I) {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
if (FD->getNumParams() == 1)

16
clang/lib/AST/DeclObjC.cpp
View File

@ -54,8 +54,8 @@ void ObjCContainerDecl::anchor() { }
///
ObjCIvarDecl *
ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
lookup_const_result R = lookup(Id);
for (lookup_const_iterator Ivar = R.begin(), IvarEnd = R.end();
lookup_result R = lookup(Id);
for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
Ivar != IvarEnd; ++Ivar) {
if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
return ivar;
@ -83,8 +83,8 @@ ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
// + (float) class_method;
// @end
//
lookup_const_result R = lookup(Sel);
for (lookup_const_iterator Meth = R.begin(), MethEnd = R.end();
lookup_result R = lookup(Sel);
for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
Meth != MethEnd; ++Meth) {
ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
if (MD && MD->isInstanceMethod() == isInstance)
@ -101,8 +101,8 @@ ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
const ObjCPropertyDecl *Property) const {
Selector Sel = Property->getSetterName();
lookup_const_result R = lookup(Sel);
for (lookup_const_iterator Meth = R.begin(), MethEnd = R.end();
lookup_result R = lookup(Sel);
for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
Meth != MethEnd; ++Meth) {
ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
if (MD && MD->isInstanceMethod() && !MD->isImplicit())
@ -161,8 +161,8 @@ ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
return nullptr;
}
DeclContext::lookup_const_result R = DC->lookup(propertyID);
for (DeclContext::lookup_const_iterator I = R.begin(), E = R.end(); I != E;
DeclContext::lookup_result R = DC->lookup(propertyID);
for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
++I)
if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I))
return PD;

4
clang/lib/Sema/SemaCodeComplete.cpp
View File

@ -799,8 +799,8 @@ void ResultBuilder::MaybeAddConstructorResults(Result R) {
DeclarationName ConstructorName
= Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(RecordTy));
DeclContext::lookup_const_result Ctors = Record->lookup(ConstructorName);
for (DeclContext::lookup_const_iterator I = Ctors.begin(),
DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
for (DeclContext::lookup_iterator I = Ctors.begin(),
E = Ctors.end();
I != E; ++I) {
R.Declaration = *I;

8
clang/lib/Sema/SemaDeclAttr.cpp
View File

@ -351,13 +351,13 @@ static bool isIntOrBool(Expr *Exp) {
// Check to see if the type is a smart pointer of some kind. We assume
// it's a smart pointer if it defines both operator-> and operator*.
static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
DeclContextLookupConstResult Res1 = RT->getDecl()->lookup(
S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
DeclContextLookupResult Res1 = RT->getDecl()->lookup(
S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
if (Res1.empty())
return false;
DeclContextLookupConstResult Res2 = RT->getDecl()->lookup(
S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
DeclContextLookupResult Res2 = RT->getDecl()->lookup(
S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
if (Res2.empty())
return false;

2
clang/lib/Sema/SemaDeclCXX.cpp
View File

@ -9069,7 +9069,7 @@ private:
ASTContext &Context = SemaRef.Context;
DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(Context.getRecordType(Base)));
DeclContext::lookup_const_result Decls = Derived->lookup(Name);
DeclContext::lookup_result Decls = Derived->lookup(Name);
return Decls.empty() ? Derived->getLocation() : Decls[0]->getLocation();
}

8
clang/lib/Sema/SemaExprCXX.cpp
View File

@ -3541,8 +3541,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
bool FoundConstructor = false;
unsigned FoundTQs;
DeclContext::lookup_const_result R = Self.LookupConstructors(RD);
for (DeclContext::lookup_const_iterator Con = R.begin(),
DeclContext::lookup_result R = Self.LookupConstructors(RD);
for (DeclContext::lookup_iterator Con = R.begin(),
ConEnd = R.end(); Con != ConEnd; ++Con) {
// A template constructor is never a copy constructor.
// FIXME: However, it may actually be selected at the actual overload
@ -3581,8 +3581,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
return true;
bool FoundConstructor = false;
DeclContext::lookup_const_result R = Self.LookupConstructors(RD);
for (DeclContext::lookup_const_iterator Con = R.begin(),
DeclContext::lookup_result R = Self.LookupConstructors(RD);
for (DeclContext::lookup_iterator Con = R.begin(),
ConEnd = R.end(); Con != ConEnd; ++Con) {
// FIXME: In C++0x, a constructor template can be a default constructor.
if (isa<FunctionTemplateDecl>(*Con))

4
clang/lib/Sema/SemaLookup.cpp
View File

@ -673,8 +673,8 @@ static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
DeclareImplicitMemberFunctionsWithName(S, R.getLookupName(), DC);
// Perform lookup into this declaration context.
DeclContext::lookup_const_result DR = DC->lookup(R.getLookupName());
for (DeclContext::lookup_const_iterator I = DR.begin(), E = DR.end(); I != E;
DeclContext::lookup_result DR = DC->lookup(R.getLookupName());
for (DeclContext::lookup_iterator I = DR.begin(), E = DR.end(); I != E;
++I) {
NamedDecl *D = *I;
if ((D = R.getAcceptableDecl(D))) {

2
clang/lib/Serialization/ASTWriter.cpp
View File

@ -3699,7 +3699,7 @@ void ASTWriter::AddUpdatedDeclContext(const DeclContext *DC) {
// Ensure we emit all the visible declarations.
visitLocalLookupResults(DC, DC->NeedToReconcileExternalVisibleStorage,
[&](DeclarationName Name,
DeclContext::lookup_const_result Result) {
DeclContext::lookup_result Result) {
for (auto *Decl : Result)
GetDeclRef(getDeclForLocalLookup(getLangOpts(), Decl));
});

2
clang/tools/libclang/CXType.cpp
View File

@ -804,7 +804,7 @@ long long clang_Type_getOffsetOf(CXType PT, const char *S) {
ASTContext &Ctx = cxtu::getASTUnit(GetTU(PT))->getASTContext();
IdentifierInfo *II = &Ctx.Idents.get(S);
DeclarationName FieldName(II);
RecordDecl::lookup_const_result Res = RD->lookup(FieldName);
RecordDecl::lookup_result Res = RD->lookup(FieldName);
// If a field of the parent record is incomplete, lookup will fail.
// and we would return InvalidFieldName instead of Incomplete.
// But this erroneous results does protects again a hidden assertion failure