Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-12-12 01:18:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Provide a naming class for UnresolvedLookupExprs, even when occuring on

Browse Source 
template names. We were completely missing naming classes for many unqualified
lookups, but this didn't trigger code paths that need it. This removes part of
an optimization that re-uses the template name lookup done by the parser to
determine if explicit template arguments actually form a template-id.
Unfortunately the technique for avoiding the duplicate lookup lost needed data
such as the class context in which the lookup succeeded.

llvm-svn: 104117
This commit is contained in:
Chandler Carruth 2010-05-19 09:39:06 +00:00
parent b243dfb085
commit 8fd2b8935e
3 changed files with 23 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
clang/lib/Sema/SemaExpr.cpp
View File

@ -1077,17 +1077,12 @@ Sema::OwningExprResult Sema::ActOnIdExpression(Scope *S,
// Perform the required lookup.
LookupResult R(*this, Name, NameLoc, LookupOrdinaryName);
if (TemplateArgs) {
// Just re-use the lookup done by isTemplateName.
DecomposeTemplateName(R, Id);
// Re-derive the naming class.
if (SS.isSet()) {
NestedNameSpecifier *Qualifier
= static_cast<NestedNameSpecifier *>(SS.getScopeRep());
if (const Type *Ty = Qualifier->getAsType())
if (CXXRecordDecl *NamingClass = Ty->getAsCXXRecordDecl())
R.setNamingClass(NamingClass);
}
// Lookup the template name again to correctly establish the context in
// which it was found. This is really unfortunate as we already did the
// lookup to determine that it was a template name in the first place. If
// this becomes a performance hit, we can work harder to preserve those
// results until we get here but it's likely not worth it.
LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false);
} else {
bool IvarLookupFollowUp = (!SS.isSet() && II && getCurMethodDecl());
LookupParsedName(R, S, &SS, !IvarLookupFollowUp);

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

@ -665,6 +665,8 @@ bool Sema::CppLookupName(LookupResult &R, Scope *S) {
//
DeclContext *OutsideOfTemplateParamDC = 0;
for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity());
// Check whether the IdResolver has anything in this scope.
bool Found = false;
for (; I != IEnd && S->isDeclScope(DeclPtrTy::make(*I)); ++I) {
@ -675,10 +677,11 @@ bool Sema::CppLookupName(LookupResult &R, Scope *S) {
}
if (Found) {
R.resolveKind();
if (S->isClassScope())
R.setNamingClass(dyn_cast<CXXRecordDecl>(Ctx));
return true;
}
DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity());
if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
S->getParent() && !S->getParent()->isTemplateParamScope()) {
// We've just searched the last template parameter scope and

13
clang/test/CXX/temp/temp.names/p2.cpp Normal file
View File

@ -0,0 +1,13 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
// Ensure that when enforcing access control an unqualified template name with
// explicit template arguments, we don't loose the context of the name lookup
// because of the required early lookup to determine if it names a template.
namespace PR7163 {
template <typename R, typename P> void h(R (*func)(P)) {}
class C {
template <typename T> static void g(T*) {};
public:
void f() { h(g<int>); }
};
}